scalatestShouldMatchersDottyNative
API
Generated with
scalatestShouldMatchersDottyNative/org.scalatest.matchers.should/Matchers/ResultOfCollectedAny

ResultOfCollectedAny

org.scalatest.matchers.should.Matchers.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.

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any

Members list

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)
       ^

Attributes

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)
       ^

Attributes

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)
       ^

Attributes

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
       ^

Attributes

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)
       ^

Attributes

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)
      ^

Attributes

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)
        ^

Attributes

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)
        ^

Attributes

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)
        ^

Attributes

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
       ^

Attributes

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)
       ^

Attributes

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")
           ^

Attributes

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")
           ^

Attributes

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")
           ^

Attributes

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*)?""")
           ^

Attributes

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
       ^

Attributes

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
       ^

Attributes

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
       ^

Attributes

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
       ^

Attributes

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
       ^

Attributes

infix def shouldBe(aType: ResultOfATypeInvocation[_]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) shouldBe a [Type]
       ^

Attributes

infix def shouldBe(anType: ResultOfAnTypeInvocation[_]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) shouldBe an [Type]
       ^

Attributes

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
        ^

Attributes

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)
            ^

Attributes

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)
            ^

Attributes

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)
             ^

Attributes

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)
             ^

Attributes

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
       ^

Attributes

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
       ^

Attributes

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)
       ^

Attributes

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
       ^

Attributes

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
       ^

Attributes

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)
       ^

Attributes

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)
       ^

Attributes

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
        ^

Attributes

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

Attributes

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
      ^

Attributes

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))
       ^

Attributes

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))
       ^

Attributes

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
       ^

Attributes

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))
        ^

Attributes

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
       ^

Attributes

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*)?""")
           ^

Attributes

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")
           ^

Attributes

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")
           ^

Attributes

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")
           ^

Attributes

override def toString: String

Overrides to return pretty toString.

Overrides to return pretty toString.

Attributes

Returns

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

Definition Classes
Any
Generated with