NotWord

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(existWord: ExistWord): ResultOfNotExist

This method enables syntax such as the following:

file should not (exist)
            ^

def apply[S](beMatcher: BeMatcher[S]): BeMatcher[S]

This method enables any BeMatcher to be negated by passing it to not.

val even = not (odd)
               ^

num should be (not (odd))

num should not be (odd)

def apply[S, TYPECLASS1[_], TYPECLASS2[_]](matcherGen2: MatcherFactory2[S, TYPECLASS1, TYPECLASS2]): MatcherFactory2[S, TYPECLASS1, TYPECLASS2]

def apply[S, TYPECLASS[_]](matcherGen1: MatcherFactory1[S, TYPECLASS]): MatcherFactory1[S, TYPECLASS]

This method enables the following syntax:

hasNoSize should not { have size (2) and equal (hasNoSize) }
                     ^

def apply[S](matcher: Matcher[S]): Matcher[S]

This method enables the following syntax, where tempFile, for example, refers to a java.io.File and exist is a Matcher[java.io.File]:

tempFile should not (exist)
                    ^

final def asInstanceOf[T0]: T0

macro def be(anType: ResultOfAnTypeInvocation[_]): Matcher[Any]

This method enables the following syntax:

result should (not be an [Book] and not be sorted)
                   ^

macro def be(aType: ResultOfATypeInvocation[_]): Matcher[Any]

This method enables the following syntax:

result should (not be a [Book] and not be sorted)
                   ^

def be(definedWord: DefinedWord): MatcherFactory1[Any, Definition]

This method enables the following syntax:

result should (not be defined and not equal something)
                   ^

def be(emptyWord: EmptyWord): MatcherFactory1[Any, Emptiness]

This method enables the following syntax:

nonEmptyList should (not be empty and not equal emptyList)
                         ^

def be(writableWord: WritableWord): MatcherFactory1[Any, Writability]

This method enables the following syntax:

fraction should (not be writable and not be writableFile)
                     ^

def be(readableWord: ReadableWord): MatcherFactory1[Any, Readability]

This method enables the following syntax:

fraction should (not be readable and not equal readableFile)
                     ^

def be[T](sortedWord: SortedWord): MatcherFactory1[Any, Sortable]

This method enables the following syntax:

fraction should (not be sorted and not be sorted)
                     ^

def be(right: Any): Matcher[Any]

This method enables be to be used for inequality comparison.

result should not be (None)
                     ^
result should not be (Some(1))
                     ^
result should not be (true)
                     ^
result should not be (false)
                     ^
sum should not be (19)
                  ^

def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[U]

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

fraction should (not be definedAt (8) and not be definedAt (0))
                     ^

def be[U](spread: Spread[U]): Matcher[U]

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

sevenDotOh should ((not be (17.1 +- 0.2)) and (not be (27.1 +- 0.2)))
                        ^

def be[T <: AnyRef](resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T]

This method enables the following syntax:

myFish should (not be theSameInstanceAs (redFish) and not be theSameInstanceAs (blueFish))
                   ^

def be[T](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[T]): Matcher[T]

This method enables the following syntax:

result should (not be a (passedMarks) and be a (validMarks)))
                   ^

def be[T <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[T]): Matcher[T]

This method enables the following syntax:

myFile should (not be an (directory) and not be an (directory))
                   ^

def be[T <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit prettifier: Prettifier, pos: Position): Matcher[T]

This method enables the following syntax:

isNotAppleMock should (not be an ('apple) and not be ('rotten))
                           ^

def be[T](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[T]): Matcher[T]

This method enables the following syntax:

result should (not be a (passedMarks) and be a (validMarks)))
                   ^

def be[T <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[T]): Matcher[T]

This method enables the following syntax, where notSoSecretFile, for example, refers to a java.io.File and directory is a BePropertyMatcher[java.io.File]:

notSoSecretFile should (not be a (directory) and have ('name ("passwords.txt")))
                            ^

def be[T <: AnyRef](resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit prettifier: Prettifier, pos: Position): Matcher[T]

This method enables the following syntax:

isNotFileMock should (not be a ('file) and have ('name ("temp.txt"))))
                          ^

def be[T <: AnyRef](bePropertyMatcher: BePropertyMatcher[T]): Matcher[T]

This method enables the following syntax, where tempFile, for example, refers to a java.io.File and hidden is a BePropertyMatcher[java.io.File]:

tempFile should (not be (hidden) and have ('name ("temp.txt")))
                   ^

def be[T <: AnyRef](symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): Matcher[T]

This method enables the following syntax:

myFile should (not be ('hidden) and have (name ("temp.txt")))
                   ^

def be[T](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[T]): Matcher[T]

This method enables the following syntax:

num should (not be >= (10) and not be < (7))
                ^

def be[T](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[T]): Matcher[T]

This method enables the following syntax:

num should (not be <= (7) and not be > (10))
                ^

def be[T](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[T]): Matcher[T]

This method enables the following syntax:

num should (not be > (10) and not be < (7))
                ^

def be[T](resultOfLessThanComparison: ResultOfLessThanComparison[T]): Matcher[T]

This method enables the following syntax:

num should (not be < (7) and not be > (10))
                ^

def be(o: Null): Matcher[AnyRef]

This method enables the following syntax:

map should (not be (null))
                ^

def be[T](beMatcher: BeMatcher[T]): Matcher[T]

This method enables the following syntax, where, for example, num is an Int and odd of type BeMatcher[Int]:

num should (not be (odd) and be <= (8))
                ^

def clone(): AnyRef

def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[Any, ValueMapping]

This method enables the following syntax:

Map("one" -> 1, "two" -> 2) should (not contain value (3))
                                        ^

def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[Any, KeyMapping]

This method enables the following syntax:

Map("one" -> 1, "two" -> 2) should (not contain key ("three"))
                                        ^

def contain(atMostOneElementOf: ResultOfAtMostOneElementOfApplication): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain atMostOneElementOf (List(5)) and not contain (3))
                        ^

def contain[T](atMostOneOf: ResultOfAtMostOneOfApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain atMostOneOf (5) and not contain (3))
                        ^

def contain(inOrderElementsOf: ResultOfInOrderElementsOfApplication): MatcherFactory1[Any, Sequencing]

This method enables the following syntax:

Array(1, 2) should (not contain inOrderElementsOf (List(1, 2, 3)) and not contain (3))
                                ^

def contain[T](inOrder: ResultOfInOrderApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Sequencing]

This method enables the following syntax:

Array(1, 2) should (not contain inOrder (1, 2, 3) and not contain (3))
                                ^

def contain(allElementsOf: ResultOfAllElementsOfApplication): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain allOf (1, 2, 3) and not contain (3))
                                ^

def contain[T](allOf: ResultOfAllOfApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain allOf (1, 2, 3) and not contain (3))
                                ^

def contain[T](inOrderOnly: ResultOfInOrderOnlyApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Sequencing]

This method enables the following syntax:

Array(1, 2) should (not contain only (1, 2, 3) and not contain (3))
                                ^

def contain[T](only: ResultOfOnlyApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain only (1, 2, 3) and not contain (3))
                                ^

def contain[T](theSameElementInOrderAs: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[Any, Sequencing]

This method enables the following syntax:

Array(1, 2) should (not contain theSameElementsInOrderAs (1, 2, 3) and not contain (3))
                                ^

def contain[T](theSameElementAs: ResultOfTheSameElementsAsApplication): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain theSameElementsAs (1, 2, 3) and not contain (3))
                                ^

def contain[T](noElementsOf: ResultOfNoElementsOfApplication): MatcherFactory1[Any, Containing]

This method enables the following syntax:

Array(1, 2) should (not contain noElementsOf (5, 6, 7))
                        ^

def contain[T](noneOf: ResultOfNoneOfApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Containing]

This method enables the following syntax:

Array(1, 2) should (not contain noneOf (5, 6, 7))
                        ^

def contain[T](atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain atLeastOneElementOf List(1, 2, 3))
                        ^

def contain[T](atLeastOneOf: ResultOfAtLeastOneOfApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Aggregating]

This method enables the following syntax:

Array(1, 2) should (not contain (5) and not contain (3))
                        ^

def contain[T](oneElementOf: ResultOfOneElementOfApplication): MatcherFactory1[Any, Containing]

This method enables the following syntax:

Array(1, 2) should (not contain oneElementOf (List(5, 6, 7)))
                        ^

def contain[T](oneOf: ResultOfOneOfApplication)(implicit prettifier: Prettifier): MatcherFactory1[Any, Containing]

This method enables the following syntax:

Array(1, 2) should (not contain oneOf (5, 6, 7))
                        ^

def contain[T](expectedElement: T): MatcherFactory1[Any, Containing]

This method enables the following syntax:

Array(1, 2) should (not contain (5) and not contain (3))
                        ^

def contain(nullValue: Null): MatcherFactory1[Any, Containing]

This method enables the following syntax:

list should (not contain (null))
                 ^

def endWith(expectedSubstring: String): Matcher[String]

This method enables the following syntax:

string should (not endWith ("blue") and not endWith ("1.7"))
                   ^

def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[String]

This method enables the following syntax:

string should (not endWith regex ("wor.d") and not startWith regex ("Hel*o"))
                   ^

final def eq(arg0: AnyRef): Boolean

def equal(o: Null): Matcher[AnyRef]

This method enables the following syntax:

map should (not equal (null))
                ^

def equal[U](spread: Spread[U]): Matcher[U]

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

sevenDotOh should ((not equal (17.1 +- 0.2)) and (not equal (27.1 +- 0.2)))
                        ^

def equal(right: Any): MatcherFactory1[Any, Equality]

This method enables the following syntax:

num should (not equal (7) and be < (9))
                ^

def equals(arg0: Any): Boolean

def finalize(): Unit

def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[String]

This method enables the following syntax:

string should (not fullyMatch regex ("Hel*o") and not include ("orld"))
                   ^

final def getClass(): Class[_]

def hashCode(): Int

def have[T](firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Matcher[T]

This method enables the following syntax, where, for example, book is of type Book and title and author are both of type HavePropertyMatcher[Book, String]:

book should (not have (title ("Moby Dick")) and (not have (author ("Melville"))))
                 ^

def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[Any, Messaging]

This method enables the following syntax:

result should (not have message ("Message from Mars!") and not have message ("Message from Mars!"))
                   ^

def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[Any, Size]

This method enables the following syntax:

Array(1, 2) should (not have size (5) and not have size (3))
                        ^

def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[Any, Length]

This method enables the following syntax:

Array(1, 2) should (not have length (5) and not have length (3))
                        ^

def include(expectedSubstring: String): Matcher[String]

This method enables the following syntax:

string should (not include ("cat") and not include ("1.7"))
                   ^

def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[String]

This method enables the following syntax:

string should (not include regex ("Hel.o") and not include regex ("""(-)?(\d+)(\.\d*)?"""))
                   ^

final def isInstanceOf[T0]: Boolean

macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]

This method enables the following syntax, where, for example, num is an Int and odd of type BeMatcher[Int]:

result should (not matchPattern { case Person("Bob", _)} and equal (result2))
                   ^

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def startWith(expectedSubstring: String): Matcher[String]

This method enables the following syntax:

string should ((not startWith ("red")) and (not startWith ("1.7")))
                    ^

def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[String]

This method enables the following syntax:

string should (not startWith regex ("hel*o") and not endWith regex ("wor.d"))
                   ^

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

Overrides toString to return "not"

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def be(tripleEqualsInvocation: TripleEqualsInvocation[_])(implicit pos: Position): Matcher[Any]

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.