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

ResultOfNotWordForCollectedAny

org.scalatest.matchers.should.Matchers.ResultOfNotWordForCollectedAny
final class ResultOfNotWordForCollectedAny[T](collected: Collected, xs: Iterable[T], original: Any, shouldBeTrue: Boolean, 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 be(right: Any): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be (7)
                  ^

Attributes

infix def be(comparison: ResultOfLessThanOrEqualToComparison[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be <= (7)
                  ^

Attributes

infix def be(comparison: ResultOfGreaterThanOrEqualToComparison[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be >= (7)
                  ^

Attributes

infix def be(comparison: ResultOfLessThanComparison[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be < (7)
                  ^

Attributes

infix def be(comparison: ResultOfGreaterThanComparison[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be > (7)
                  ^

Attributes

infix def be(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]:

all(xs) should not be (odd)
                  ^

Attributes

infix def be(bePropertyMatcher: BePropertyMatcher[T]): Assertion

This method enables the following syntax, where stack is, for example, of type Stack and empty refers to a BePropertyMatcher[Stack]:

This method enables the following syntax, where stack is, for example, of type Stack and empty refers to a BePropertyMatcher[Stack]:

all(xs) should not be (empty)
                  ^

Attributes

infix def be[U >: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Assertion

This method enables the following syntax, where notFileMock is, for example, of type File and file refers to a BePropertyMatcher[File]:

This method enables the following syntax, where notFileMock is, for example, of type File and file refers to a BePropertyMatcher[File]:

all(xs) should not be a (file)
                  ^

Attributes

infix def be[U >: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U]): Assertion

This method enables the following syntax, where keyEvent is, for example, of type KeyEvent and actionKey refers to a BePropertyMatcher[KeyEvent]:

This method enables the following syntax, where keyEvent is, for example, of type KeyEvent and actionKey refers to a BePropertyMatcher[KeyEvent]:

all(keyEvents) should not be an (actionKey)
                         ^

Attributes

infix def be(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be theSameInstanceAs (string)
                  ^

Attributes

infix def be[U](resultOfDefinedAt: ResultOfDefinedAt[U])(implicit ev: T <:< PartialFunction[U, _]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be definedAt ("apple")
                  ^

Attributes

infix def be(o: Null)(implicit ev: T <:< AnyRef): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be (null)
                  ^

Attributes

infix def be(sortedWord: SortedWord)(implicit sortable: Sortable[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be sorted
                  ^

Attributes

infix def be(readableWord: ReadableWord)(implicit readability: Readability[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be readable
                  ^

Attributes

infix def be(writableWord: WritableWord)(implicit writability: Writability[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be writable
                  ^

Attributes

infix def be(emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be empty
                  ^

Attributes

infix def be(definedWord: DefinedWord)(implicit definition: Definition[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not be defined
                  ^

Attributes

infix def contain(nullValue: Null)(implicit containing: Containing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain (null)
                   ^

Attributes

infix def contain(expectedElement: Any)(implicit containing: Containing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain ("one")
                   ^

Attributes

infix def contain(oneOf: ResultOfOneOfApplication)(implicit containing: Containing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain oneOf ("one")
                   ^

Attributes

infix def contain(oneElementOf: ResultOfOneElementOfApplication)(implicit containing: Containing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain oneElementOf ("one")
                   ^

Attributes

infix def contain(atLeastOneOf: ResultOfAtLeastOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain atLeastOneOf ("one")
                   ^

Attributes

infix def contain(atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication)(implicit evidence: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain atLeastOneElementOf ("one")
                   ^

Attributes

infix def contain(noneOf: ResultOfNoneOfApplication)(implicit containing: Containing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain noneOf ("one")
                   ^

Attributes

infix def contain(noElementsOf: ResultOfNoElementsOfApplication)(implicit evidence: Containing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain noElementsOf ("one")
                   ^

Attributes

infix def contain(theSameElementsAs: ResultOfTheSameElementsAsApplication)(implicit aggregating: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain theSameElementsAs ("one")
                   ^

Attributes

infix def contain(theSameElementsInOrderAs: ResultOfTheSameElementsInOrderAsApplication)(implicit sequencing: Sequencing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain theSameElementsInOrderAs ("one")
                   ^

Attributes

infix def contain(only: ResultOfOnlyApplication)(implicit aggregating: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain only ("one")
                   ^

Attributes

infix def contain(only: ResultOfInOrderOnlyApplication)(implicit sequencing: Sequencing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain inOrderOnly ("one", "two")
                   ^

Attributes

infix def contain(only: ResultOfAllOfApplication)(implicit aggregating: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain allOf ("one")
                   ^

Attributes

infix def contain(only: ResultOfAllElementsOfApplication)(implicit evidence: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain allElementsOf ("one")
                   ^

Attributes

infix def contain(inOrder: ResultOfInOrderApplication)(implicit sequencing: Sequencing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain inOrder ("one")
                   ^

Attributes

infix def contain(inOrderElementsOf: ResultOfInOrderElementsOfApplication)(implicit evidence: Sequencing[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain inOrderElementsOf (List("one"))
                   ^

Attributes

infix def contain(atMostOneOf: ResultOfAtMostOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain atMostOneOf ("one")
                   ^

Attributes

infix def contain(atMostOneElementOf: ResultOfAtMostOneElementOfApplication)(implicit evidence: Aggregating[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all (xs) should not contain atMostOneElementOf List("one")
                   ^

Attributes

infix def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication)(implicit keyMapping: KeyMapping[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(colOfMap) should not contain key ("three")
                        ^

Attributes

infix def contain(resultOfValueWordApplication: ResultOfValueWordApplication)(implicit valueMapping: ValueMapping[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(colOfMap) should not contain value (3)
                        ^

Attributes

infix def endWith(expectedSubstring: String)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not endWith ("1.7")
                      ^

Attributes

infix def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not endWith regex ("wor.d")
                      ^

Attributes

infix def equal(right: Any)(implicit equality: Equality[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not equal (7)
                  ^

Attributes

infix def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
                      ^

The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

Attributes

infix def have(resultOfLengthWordApplication: ResultOfLengthWordApplication)(implicit len: Length[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not have length (0)
                  ^

Attributes

infix def have(resultOfSizeWordApplication: ResultOfSizeWordApplication)(implicit sz: Size[T]): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(xs) should not have size (0)
                  ^

Attributes

infix def have[U >: T](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): Assertion

This method enables the following syntax, where badBook is, for example, of type Book and title ("One Hundred Years of Solitude") results in a HavePropertyMatcher[Book]:

This method enables the following syntax, where badBook is, for example, of type Book and title ("One Hundred Years of Solitude") results in a HavePropertyMatcher[Book]:

all(books) should not have (title ("One Hundred Years of Solitude"))
                     ^

Attributes

infix def include(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not include regex ("wo.ld")
                      ^

The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

Attributes

infix def include(expectedSubstring: String)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not include ("world")
                      ^

Attributes

infix def startWith(right: String)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not startWith ("1.7")
                      ^

Attributes

infix def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: T <:< String): Assertion

This method enables the following syntax:

This method enables the following syntax:

all(string) should not startWith regex ("Hel*o")
                      ^

The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

Attributes

override def toString: String

Overrides to return pretty toString.

Overrides to return pretty toString.

Attributes

Returns

"ResultOfNotWordForCollectedAny([collected], [xs], [shouldBeTrue])"

Definition Classes
Any

Deprecated methods

infix def be(comparison: TripleEqualsInvocation[_]): Nothing

Note: usually syntax will be removed after its deprecation period. This was left in because otherwise the syntax could in some cases still compile, but silently wouldn't work.

The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

Note: usually syntax will be removed after its deprecation period. This was left in because otherwise the syntax could in some cases still compile, but silently wouldn't work.

Attributes

Deprecated
true
Generated with