scalatestMatchersCoreDotty
API
Generated with
scalatestMatchersCoreDotty/org.scalatest.matchers/org.scalatest.matchers.dsl/MatcherFactory7/OrNotWord

OrNotWord

org.scalatest.matchers.dsl.MatcherFactory7.OrNotWord
final class OrNotWord(prettifier: Prettifier, pos: Position)

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

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type

Members list

Value members

Concrete methods

infix def be(any: Any): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be (2)
                      ^

Attributes

infix def be(o: Null): MatcherFactory7[SC & AnyRef, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be (null)
                      ^

Attributes

infix def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be < (8)
                      ^

Attributes

infix def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be > (6)
                      ^

Attributes

infix def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be <= (2)
                      ^

Attributes

infix def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be >= (6)
                      ^

Attributes

infix def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

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

infix def be[U](beMatcher: BeMatcher[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7, where odd is a BeMatcher:

This method enables the following syntax given a MatcherFactory7, where odd is a BeMatcher:

aMatcherFactory or not be (odd)
                      ^

Attributes

infix def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory7[SC & AnyRef & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7, where file is a BePropertyMatcher:

This method enables the following syntax given a MatcherFactory7, where file is a BePropertyMatcher:

aMatcherFactory or not be (file)
                      ^

Attributes

infix def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7, where validMarks is an AMatcher:

This method enables the following syntax given a MatcherFactory7, where validMarks is an AMatcher:

aMatcherFactory or not be a (validMarks)
                      ^

Attributes

infix def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7, where file is a BePropertyMatcher:

This method enables the following syntax given a MatcherFactory7, where file is a BePropertyMatcher:

aMatcherFactory or not be a (file)
                      ^

Attributes

infix def be[U <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7, where apple is a BePropertyMatcher:

This method enables the following syntax given a MatcherFactory7, where apple is a BePropertyMatcher:

aMatcherFactory or not be an (apple)
                      ^

Attributes

infix def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7, where invalidMarks is an AnMatcher:

This method enables the following syntax given a MatcherFactory7, where invalidMarks is an AnMatcher:

aMatcherFactory and not be an (invalidMarks)
                       ^

Attributes

infix inline def be(aType: ResultOfATypeInvocation[_]): MatcherFactory7[SC & AnyRef, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be a [Book]
                      ^

Attributes

infix inline def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory7[SC & AnyRef, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be an [Apple]
                      ^

Attributes

infix def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory7[SC & AnyRef, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not be theSameInstanceAs (string)
                      ^

Attributes

infix def be[U](spread: Spread[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax for the "primitive" numeric types:

This method enables the following syntax for the "primitive" numeric types:

aMatcherFactory or not be (17.0 +- 0.2)
                      ^

Attributes

infix def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax, where fraction is a PartialFunction:

This method enables the following syntax, where fraction is a PartialFunction:

aMatcherFactory or not be definedAt (8)
                      ^

Attributes

infix def be(sortedWord: SortedWord): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Sortable]

This method enables the following syntax, where fraction is a PartialFunction:

This method enables the following syntax, where fraction is a PartialFunction:

aMatcherFactory or not be sorted
                      ^

Attributes

infix def be(readableWord: ReadableWord): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Readability]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be readable
                      ^

Attributes

infix def be(writableWord: WritableWord): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Writability]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be writable
                      ^

Attributes

infix def be(emptyWord: EmptyWord): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Emptiness]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be empty
                      ^

Attributes

infix def be(definedWord: DefinedWord): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Definition]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be defined
                      ^

Attributes

infix def contain[U](expectedElement: U): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Containing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain (3)
                      ^

Attributes

infix def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, KeyMapping]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain key ("three")
                      ^

Attributes

infix def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, ValueMapping]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain value (3)
                      ^

Attributes

infix def contain(right: ResultOfOneOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Containing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain oneOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfOneElementOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Containing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain oneOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain atLeastOneOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain atLeastOneElementOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfNoneOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Containing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain noneOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfNoElementsOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Containing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain noElementsOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain theSameElementsAs (List(8, 1, 2))
                      ^

Attributes

infix def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Sequencing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain theSameElementsInOrderAs (List(8, 1, 2))
                      ^

Attributes

infix def contain(right: ResultOfOnlyApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain only (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Sequencing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain inOrderOnly (8, 1, 2))
                      ^

Attributes

infix def contain(right: ResultOfAllOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain allOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfAllElementsOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain allOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfInOrderApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Sequencing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain inOrder (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Sequencing]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain inOrderElementsOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain atMostOneOf (8, 1, 2)
                      ^

Attributes

infix def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Aggregating]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not contain atMostOneElementOf (List(8, 1, 2))
                      ^

Attributes

infix def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not endWith regex (decimal)
                      ^

Attributes

infix def endWith(expectedSubstring: String): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not endWith ("1.7")
                      ^

Attributes

infix def equal(any: Any): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Equality]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not equal (3 - 1)
                      ^

Attributes

infix def equal[U](spread: Spread[U]): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax for the "primitive" numeric types:

This method enables the following syntax for the "primitive" numeric types:

aMatcherFactory or not equal (17.0 +- 0.2)
                      ^

Attributes

infix def equal(o: Null): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not equal (null)
                      ^

Attributes

infix def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not fullyMatch regex (decimal)
                      ^

Attributes

infix def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Length]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not have length (3)
                      ^

Attributes

infix def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Size]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not have size (3)
                      ^

Attributes

infix def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory8[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7, Messaging]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not have message ("Message from Mars!")
                      ^

Attributes

infix def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory7[SC & U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not have (author ("Melville"))
                      ^

Attributes

infix def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not include regex (decimal)
                      ^

Attributes

infix def include(expectedSubstring: String): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not include ("1.7")
                      ^

Attributes

infix inline def matchPattern(inline right: PartialFunction[Any, _]): MatcherFactory7[SC & AnyRef, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not matchPattern { case Person("Bob", _) =>}
                      ^

Attributes

infix def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not startWith regex (decimal)
                      ^

Attributes

infix def startWith(expectedSubstring: String): MatcherFactory7[SC & String, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

This method enables the following syntax given a MatcherFactory7:

This method enables the following syntax given a MatcherFactory7:

aMatcherFactory or not startWith ("1.7")
                      ^

Attributes

Concrete fields

val owner: MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

Get the MatcherFactory instance, currently used by macro.

Get the MatcherFactory instance, currently used by macro.

Attributes

Generated with