scalatestMatchersCoreDottyNative/org.scalatest.matchers.dsl/MatcherFactory4/OrNotWord

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.

class Object
trait Matchable
class Any

Value members

Concrete methods

infix def be(any: Any): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be (2)
                      ^
infix def be(o: Null): MatcherFactory4[SC & AnyRef, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be (null)
                      ^
infix def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be < (8)
                      ^
infix def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be > (6)
                      ^
infix def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be <= (2)
                      ^
infix def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be >= (6)
                      ^
infix def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

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.

infix def be[U](beMatcher: BeMatcher[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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

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

aMatcherFactory or not be (odd)
                      ^
infix def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory4[SC & AnyRef & U, TC1, TC2, TC3, TC4]

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

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

aMatcherFactory or not be (file)
                      ^
infix def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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

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

aMatcherFactory or not be a (validMarks)
                      ^
infix def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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

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

aMatcherFactory or not be a (file)
                      ^
infix def be[U <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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

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

aMatcherFactory or not be an (apple)
                      ^
infix def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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

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

aMatcherFactory and not be an (invalidMarks)
                       ^
infix inline def be(aType: ResultOfATypeInvocation[_]): MatcherFactory4[SC & AnyRef, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be a [Book]
                      ^
infix inline def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory4[SC & AnyRef, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be an [Apple]
                      ^
infix def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory4[SC & AnyRef, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not be theSameInstanceAs (string)
                      ^
infix def be[U](spread: Spread[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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)
                      ^
infix def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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)
                      ^
infix def be(sortedWord: SortedWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, 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
                      ^
infix def be(readableWord: ReadableWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Readability]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be readable
                      ^
infix def be(writableWord: WritableWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Writability]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be writable
                      ^
infix def be(emptyWord: EmptyWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Emptiness]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be empty
                      ^
infix def be(definedWord: DefinedWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Definition]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not be defined
                      ^
infix def contain[U](expectedElement: U): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain (3)
                      ^
infix def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, KeyMapping]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain key ("three")
                      ^
infix def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, ValueMapping]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain value (3)
                      ^
infix def contain(right: ResultOfOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain oneOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain oneOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain atLeastOneOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain atLeastOneElementOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfNoneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain noneOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfNoElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain noElementsOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain theSameElementsAs (List(8, 1, 2))
                      ^
infix def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain theSameElementsInOrderAs (List(8, 1, 2))
                      ^
infix def contain(right: ResultOfOnlyApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain only (8, 1, 2)
                      ^
infix def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain inOrderOnly (8, 1, 2))
                      ^
infix def contain(right: ResultOfAllOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain allOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfAllElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain allOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfInOrderApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain inOrder (8, 1, 2)
                      ^
infix def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain inOrderElementsOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain atMostOneOf (8, 1, 2)
                      ^
infix def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not contain atMostOneElementOf (List(8, 1, 2))
                      ^
infix def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not endWith regex (decimal)
                      ^
infix def endWith(expectedSubstring: String): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not endWith ("1.7")
                      ^
infix def equal(any: Any): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Equality]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not equal (3 - 1)
                      ^
infix def equal[U](spread: Spread[U]): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

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)
                      ^
infix def equal(o: Null): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not equal (null)
                      ^
infix def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not fullyMatch regex (decimal)
                      ^
infix def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Length]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not have length (3)
                      ^
infix def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Size]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not have size (3)
                      ^
infix def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Messaging]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not have message ("Message from Mars!")
                      ^
infix def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory4[SC & U, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not have (author ("Melville"))
                      ^
infix def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not include regex (decimal)
                      ^
infix def include(expectedSubstring: String): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not include ("1.7")
                      ^
infix inline def matchPattern(inline right: PartialFunction[Any, _]): MatcherFactory4[SC & AnyRef, TC1, TC2, TC3, TC4]

This method enables the following syntax:

This method enables the following syntax:

aMatcherFactory or not matchPattern { case Person("Bob", _) =>}
                      ^
infix def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not startWith regex (decimal)
                      ^
infix def startWith(expectedSubstring: String): MatcherFactory4[SC & String, TC1, TC2, TC3, TC4]

This method enables the following syntax given a MatcherFactory4:

This method enables the following syntax given a MatcherFactory4:

aMatcherFactory or not startWith ("1.7")
                      ^

Concrete fields

val owner: MatcherFactory4[SC, TC1, TC2, TC3, TC4]

Get the MatcherFactory instance, currently used by macro.

Get the MatcherFactory instance, currently used by macro.