final class ResultOfNotWordForAny[T] extends AnyRef
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers
for an overview of
the matchers DSL.
- Alphabetic
- By Inheritance
- ResultOfNotWordForAny
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new ResultOfNotWordForAny(left: T, shouldBeTrue: Boolean, prettifier: Prettifier, pos: Position)
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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def be[U](definedWord: DefinedWord)(implicit definition: Definition[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
option should not be defined ^
- def be[U](emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
list should not be empty ^
- def be[U](writableWord: WritableWord)(implicit writability: Writability[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
file should not be writable ^
- def be[U](readableWord: ReadableWord)(implicit readability: Readability[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
file should not be readable ^
- def be[U](sortedWord: SortedWord)(implicit sortable: Sortable[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
xs should not be sorted ^
- def be(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[T, AnyRef]): Assertion
This method enables the following syntax:
This method enables the following syntax:
otherString should not be theSameInstanceAs (string) ^
- def be[U >: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion
This method enables the following syntax, where
keyEvent
is, for example, of typeKeyEvent
andactionKey
refers to aBePropertyMatcher[KeyEvent]
:This method enables the following syntax, where
keyEvent
is, for example, of typeKeyEvent
andactionKey
refers to aBePropertyMatcher[KeyEvent]
:keyEvent should not be an (actionKey) ^
- def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[T, AnyRef], prettifier: Prettifier, pos: Position): Assertion
This method enables the following syntax:
This method enables the following syntax:
keyEvent should not be an ('actionKey) ^
- def be[U >: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion
This method enables the following syntax, where
notFileMock
is, for example, of typeFile
andfile
refers to aBePropertyMatcher[File]
:This method enables the following syntax, where
notFileMock
is, for example, of typeFile
andfile
refers to aBePropertyMatcher[File]
:notFileMock should not be a (file) ^
- def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: <:<[T, AnyRef], prettifier: Prettifier, pos: Position): Assertion
This method enables the following syntax:
This method enables the following syntax:
notFileMock should not be a ('file) ^
- def be(bePropertyMatcher: BePropertyMatcher[T])(implicit ev: <:<[T, AnyRef]): Assertion
This method enables the following syntax, where
stack
is, for example, of typeStack
andempty
refers to aBePropertyMatcher[Stack]
:This method enables the following syntax, where
stack
is, for example, of typeStack
andempty
refers to aBePropertyMatcher[Stack]
:stack should not be (empty) ^
- def be(symbol: Symbol)(implicit toAnyRef: <:<[T, AnyRef], prettifier: Prettifier, pos: Position): Assertion
This method enables the following syntax:
This method enables the following syntax:
stack should not be ('empty) ^
- def be(o: Null)(implicit ev: <:<[T, AnyRef]): Assertion
This method enables the following syntax:
This method enables the following syntax:
map should not be (null) ^
- def be[U](resultOfDefinedAt: ResultOfDefinedAt[U])(implicit ev: <:<[T, PartialFunction[U, _]]): Assertion
This method enables the following syntax:
This method enables the following syntax:
partialFun should not be definedAt ("apple") ^
- def be(spread: Spread[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
sevenDotOh should not be (6.5 +- 0.2) ^
- macro def be(anType: ResultOfAnTypeInvocation[_]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be a [Book] ^
- macro def be(aType: ResultOfATypeInvocation[_]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be a [Book] ^
- def be(resultOfAnWordToAnMatcherApplication: ResultOfAnWordToAnMatcherApplication[T]): Assertion
This method enables the following syntax, where
oddNumber
refers to anAnMatcher[Int]
:This method enables the following syntax, where
oddNumber
refers to anAnMatcher[Int]
:2 should not be an (oddNumber) ^
- def be(resultOfAWordToAMatcherApplication: ResultOfAWordToAMatcherApplication[T]): Assertion
This method enables the following syntax, where
positiveNumber
refers to anAMatcher[Int]
:This method enables the following syntax, where
positiveNumber
refers to anAMatcher[Int]
:2 should not be a (positiveNumber) ^
- def be(beMatcher: BeMatcher[T]): Assertion
This method enables the following syntax, where
odd
refers to aBeMatcher[Int]
:This method enables the following syntax, where
odd
refers to aBeMatcher[Int]
:2 should not be (odd) ^
- def be(comparison: ResultOfGreaterThanComparison[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be > (7) ^
- def be(comparison: ResultOfLessThanComparison[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be < (7) ^
- def be(comparison: ResultOfGreaterThanOrEqualToComparison[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be >= (7) ^
- def be(comparison: ResultOfLessThanOrEqualToComparison[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be <= (7) ^
- def be(right: Any): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not be (7) ^
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def contain(resultOfValueWordApplication: ResultOfValueWordApplication)(implicit valueMapping: ValueMapping[T]): Assertion
- def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication)(implicit keyMapping: KeyMapping[T]): Assertion
- def contain(atMostOneElementOf: ResultOfAtMostOneElementOfApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(atMostOneOf: ResultOfAtMostOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(only: ResultOfInOrderElementsOfApplication)(implicit sequencing: Sequencing[T]): Assertion
- def contain(only: ResultOfInOrderApplication)(implicit sequencing: Sequencing[T]): Assertion
- def contain(allElementsOf: ResultOfAllElementsOfApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(allOf: ResultOfAllOfApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(only: ResultOfInOrderOnlyApplication)(implicit sequencing: Sequencing[T]): Assertion
- def contain(only: ResultOfOnlyApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(theSameElementsInOrderAs: ResultOfTheSameElementsInOrderAsApplication)(implicit sequencing: Sequencing[T]): Assertion
- def contain(theSameElementsAs: ResultOfTheSameElementsAsApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(noElementsOf: ResultOfNoElementsOfApplication)(implicit containing: Containing[T]): Assertion
- def contain(noneOf: ResultOfNoneOfApplication)(implicit containing: Containing[T]): Assertion
- def contain(atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(atLeastOneOf: ResultOfAtLeastOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion
- def contain(oneElementOf: ResultOfOneElementOfApplication)(implicit evidence: Containing[T]): Assertion
- def contain(newOneOf: ResultOfOneOfApplication)(implicit containing: Containing[T]): Assertion
- def contain(expectedElement: Any)(implicit containing: Containing[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
object should not contain ("one") ^
- def contain(nullValue: Null)(implicit containing: Containing[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
object should not contain (null) ^
- def endWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
"eight" should not endWith ("1.7") ^
- def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
greeting should not endWith regex ("wor.d") ^
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equal(right: Null): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not equal null ^
- def equal(spread: Spread[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
sevenDotOh should not equal (6.5 +- 0.2) ^
- def equal(right: Any)(implicit equality: Equality[T]): Assertion
This method enables the following syntax:
This method enables the following syntax:
result should not equal (7) ^
- 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)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
string should not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""") ^
The regular expression passed following the
regex
token can be either aString
or ascala.util.matching.Regex
. - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def have(resultOfMessageWordApplication: ResultOfMessageWordApplication)(implicit messaging: Messaging[T]): Assertion
- def have(firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Assertion
This method enables the following syntax, where
badBook
is, for example, of typeBook
andtitle ("One Hundred Years of Solitude")
results in aHavePropertyMatcher[Book]
:This method enables the following syntax, where
badBook
is, for example, of typeBook
andtitle ("One Hundred Years of Solitude")
results in aHavePropertyMatcher[Book]
:book should not have (title ("One Hundred Years of Solitude")) ^
- def have(resultOfSizeWordApplication: ResultOfSizeWordApplication)(implicit sz: Size[T]): Assertion
Enables parentheses to be placed around
size (N)
in expressions of the form:should not have (size (N))
. - def have(resultOfLengthWordApplication: ResultOfLengthWordApplication)(implicit len: Length[T]): Assertion
Enables parentheses to be placed around
length (N)
in expressions of the form:should not have (length (N))
. - def include(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
string should not include ("world") ^
- def include(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
string should not include regex ("wo.ld") ^
The regular expression passed following the
regex
token can be either aString
or ascala.util.matching.Regex
. - final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val left: T
- macro def matchPattern(right: PartialFunction[Any, _]): Unit
This method enables the following syntax:
This method enables the following syntax:
result should not matchPattern { case Person("Bob", _) => } ^
- 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()
- val pos: Position
- val prettifier: Prettifier
- val shouldBeTrue: Boolean
- def startWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
"eight" should not startWith ("1.7") ^
- def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion
This method enables the following syntax:
This method enables the following syntax:
string should not startWith regex ("Hel*o") ^
The regular expression passed following the
regex
token can be either aString
or ascala.util.matching.Regex
. - final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
Overrides toString to return pretty text.
Overrides toString to return pretty text.
- Definition Classes
- ResultOfNotWordForAny → 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(comparison: TripleEqualsInvocation[_]): 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.