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
- All
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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- 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: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.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[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- 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))
.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))
.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, _]): _$7 forSome {type _$7}
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
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- 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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
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.