final class NotWord extends AnyRef
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers
for an overview of
the matchers DSL.
- Source
- NotWord.scala
- Alphabetic
- By Inheritance
- NotWord
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new NotWord()
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def apply(existWord: ExistWord): ResultOfNotExist
This method enables syntax such as the following:
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 tonot
.This method enables any
BeMatcher
to be negated by passing it tonot
. For example, if you have aBeMatcher[Int]
calledodd
, which matchesInt
s that are odd, you can negate it to get aBeMatcher[Int]
that matches evenInt
s, like this:val even = not (odd) ^
In addition, this method enables you to negate a
BeMatcher
at its point of use, like this:num should be (not (odd))
Nevertheless, in such as case it would be more idiomatic to write:
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:
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 ajava.io.File
andexist
is aMatcher[java.io.File]
:This method enables the following syntax, where
tempFile
, for example, refers to ajava.io.File
andexist
is aMatcher[java.io.File]
:tempFile should not (exist) ^
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- macro def be(anType: ResultOfAnTypeInvocation[_]): Matcher[Any]
This method enables the following syntax:
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:
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:
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:
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:
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:
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:
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.This method enables
be
to be used for inequality comparison. Here are some examples: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
: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:
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:
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:
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:
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:
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:
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 ajava.io.File
anddirectory
is aBePropertyMatcher[java.io.File]
:This method enables the following syntax, where
notSoSecretFile
, for example, refers to ajava.io.File
anddirectory
is aBePropertyMatcher[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:
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 ajava.io.File
andhidden
is aBePropertyMatcher[java.io.File]
:This method enables the following syntax, where
tempFile
, for example, refers to ajava.io.File
andhidden
is aBePropertyMatcher[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:
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:
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:
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:
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:
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:
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 anInt
andodd
of typeBeMatcher[Int]
:This method enables the following syntax, where, for example,
num
is anInt
andodd
of typeBeMatcher[Int]
:num should (not be (odd) and be <= (8)) ^
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[Any, ValueMapping]
This method enables the following syntax:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
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:
This method enables the following syntax:
list should (not contain (null)) ^
- def endWith(expectedSubstring: String): Matcher[String]
This method enables the following syntax:
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:
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
- Definition Classes
- AnyRef
- def equal(o: Null): Matcher[AnyRef]
This method enables the following syntax:
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:
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:
This method enables the following syntax:
num should (not equal (7) and be < (9)) ^
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[String]
This method enables the following syntax:
This method enables the following syntax:
string should (not fullyMatch regex ("Hel*o") and not include ("orld")) ^
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def have[T](firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Matcher[T]
This method enables the following syntax, where, for example,
book
is of typeBook
andtitle
andauthor
are both of typeHavePropertyMatcher[Book, String]
:This method enables the following syntax, where, for example,
book
is of typeBook
andtitle
andauthor
are both of typeHavePropertyMatcher[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:
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:
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:
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:
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:
This method enables the following syntax:
string should (not include regex ("Hel.o") and not include regex ("""(-)?(\d+)(\.\d*)?""")) ^
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]
This method enables the following syntax, where, for example,
num
is anInt
andodd
of typeBeMatcher[Int]
:This method enables the following syntax, where, for example,
num
is anInt
andodd
of typeBeMatcher[Int]
:result should (not matchPattern { case Person("Bob", _)} and equal (result2)) ^
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def startWith(expectedSubstring: String): Matcher[String]
This method enables the following syntax:
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:
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
- Definition Classes
- AnyRef
- def toString(): String
Overrides toString to return "not"
Overrides toString to return "not"
- Definition Classes
- NotWord → AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Deprecated Value Members
- 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.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.
- Annotations
- @deprecated
- Deprecated
The deprecation period for the be === syntax has expired. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.