scalatestShouldMatchersDottyNative/org.scalatest.matchers.should/Matchers/ResultOfNotWordForCollectedAny

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.

class Object
trait Matchable
class Any

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

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

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

override def toString: String

Overrides to return pretty toString.

Overrides to return pretty toString.

Returns:

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

Definition Classes
Any

Deprecated methods

@deprecated("The deprecation period for the be === syntax has expired. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.")
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.

Deprecated