org.scalatest.matchers.Matchers.MatcherWrapper.AndNotWord

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

AndNotWord
AnyRef
Any

Visibility

Public
All

Instance Constructors

new AndNotWord ()

Value Members

def != (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def != (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def ## (): Int

Attributes
final
Definition Classes
AnyRef → Any
def == (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def == (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any

def be (byteTolerance: ByteTolerance): Matcher[T with Byte]

This method enables the following syntax:

sevenByte should ((not be (19.toByte plusOrMinus 2.toByte)) and (not be (19.toByte plusOrMinus 2.toByte)))
                                                                     ^

def be (shortTolerance: ShortTolerance): Matcher[T with Short]

This method enables the following syntax:

sevenShort should (not be (17.toShort plusOrMinus 2.toShort) and not be (17.toShort plusOrMinus 2.toShort))
                                                                     ^

def be (intTolerance: IntTolerance): Matcher[T with Int]

This method enables the following syntax:
This method enables the following syntax:
```
sevenInt should (not be (17 plusOrMinus 2) and not be (17 plusOrMinus 2))
                                                   ^
```

def be (longTolerance: LongTolerance): Matcher[T with Long]

This method enables the following syntax:

sevenLong should (not be (17L plusOrMinus 2L) and not be (17L plusOrMinus 2L))
                                                      ^

def be (floatTolerance: FloatTolerance): Matcher[T with Float]

This method enables the following syntax:

sevenDotOhFloat should (not be (17.0f plusOrMinus 0.2f) and not be (17.0f plusOrMinus 0.2f))
                                                                ^

def be (doubleTolerance: DoubleTolerance): Matcher[T with Double]

This method enables the following syntax:

sevenDotOh should (not be (17.0 plusOrMinus 0.2) and not be (17.0 plusOrMinus 0.2))
                                                         ^

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

This method enables the following syntax:
This method enables the following syntax:
```
obj should (not be theSameInstanceAs (otherString) and not be theSameInstanceAs (otherString))
                                                           ^
```
def be [T <: AnyRef] (resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[T]): Matcher[T with 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 (resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T with AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
isNotAppleMock should (not be an ('apple) and not be an ('apple))
                                                  ^
```
def be [U <: AnyRef] (resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
myFile should (not be a (directory) and not be a (directory))
                                            ^
```
def be (resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T with AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
isNotFileMock should (not be a ('file) and not be a ('file))
                                               ^
```
def be [U] (bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U]

This method enables the following syntax:
This method enables the following syntax:
```
myFile should (not be (directory) and not be (directory))
                                             ^
```
def be [U] (beMatcher: BeMatcher[U]): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
2 should (not be (odd) and not be (odd))
                               ^
```
def be (symbol: Symbol): Matcher[T with AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
notEmptyMock should (not be ('empty) and not be ('empty))
                                             ^
```
def be (resultOfTripleEqualsApplication: ResultOfTripleEqualsApplication): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
5 should (not be === (2) and not be === (6))
                                 ^
```
def be [U] (resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
7 should (not be >= (8) and not be >= (6))
                                ^
```
def be [U] (resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
2 should (not be <= (1) and not be <= (2))
                                ^
```
def be [U] (resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
7 should (not be > (8) and not be > (6))
                               ^
```
def be (o: Null): Matcher[T with AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
map should (contain key (7) and not be (null))
                                    ^
```
def be [U] (resultOfLessThanComparison: ResultOfLessThanComparison[U]): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
5 should (not be < (2) and not be < (6))
                               ^
```
def be (any: Any): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
1 should (not be (2) and not be (3 - 1))
                             ^
```
def clone (): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def contain [U] (resultOfValueWordApplication: ResultOfValueWordApplication[U]): Matcher[T with scala.collection.Map[K,U] forSome { type K }]

This method enables the following syntax:
This method enables the following syntax:
```
Map("one" -> 1, "two" -> 2) should (not contain value (5) and not contain value (3))
                                                                  ^
```
def contain [U] (resultOfKeyWordApplication: ResultOfKeyWordApplication[U]): Matcher[T with Map[U, Any]]

This method enables the following syntax:
This method enables the following syntax:
```
Map("one" -> 1, "two" -> 2) should (not contain key ("five") and not contain key ("three"))
                                                                     ^
```
def contain [U] (expectedElement: U): Matcher[T with Traversable[U]]

This method enables the following syntax:
This method enables the following syntax:
```
Array(1, 2) should (not contain (5) and not contain (3))
                                                    ^
```
def endWith (expectedSubstring: String): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not endWith ("fre") and not endWith ("1.7"))
                                           ^
```
def endWith (resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not endWith regex ("bob") and not endWith regex (decimal))
                                                 ^
```
def eq (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def equal (any: Any): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
1 should (not equal (2) and not equal (3 - 1))
                                ^
```
def equals (arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def fullyMatch (resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not fullyMatch regex ("bob") and not fullyMatch regex (decimal))
                                                    ^
```
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef
def hashCode (): Int

Definition Classes
AnyRef → Any
def have [U] (firstPropertyMatcher: org.scalatest.matchers.HavePropertyMatcher[U, _], propertyMatchers: org.scalatest.matchers.HavePropertyMatcher[U, _]*): Matcher[T with U]

This method enables the following syntax:
This method enables the following syntax:
```
book should (not have (title ("Moby Dick")) and not have (author ("Melville")))
                                                    ^
```
def have (resultOfSizeWordApplication: ResultOfSizeWordApplication): Matcher[T with AnyRef]

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): Matcher[T with AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
Array(1, 2) should (not have size (5) and not have length (3))
                                              ^
```
def include (expectedSubstring: String): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not include ("bob") and not include ("1.7"))
                                           ^
```
def include (resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not include regex ("bob") and not include regex (decimal))
                                                    ^
```
def isInstanceOf [T0] : Boolean

Attributes
final
Definition Classes
Any
def ne (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

Attributes
final
Definition Classes
AnyRef
def startWith (expectedSubstring: String): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not startWith ("red") and not startWith ("1.7"))
                                             ^
```
def startWith (resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

This method enables the following syntax:
This method enables the following syntax:
```
"fred" should (not startWith regex ("bob") and not startWith regex (decimal))
                                                   ^
```
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
def toString (): String

Definition Classes
AnyRef → Any
def wait (): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long, arg1: Int): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()

AndNotWord

class AndNotWord extends AnyRef

Instance Constructors

new AndNotWord ()

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def asInstanceOf [T0] : T0

def be (byteTolerance: ByteTolerance): Matcher[T with Byte]

def be (shortTolerance: ShortTolerance): Matcher[T with Short]

def be (intTolerance: IntTolerance): Matcher[T with Int]

def be (longTolerance: LongTolerance): Matcher[T with Long]

def be (floatTolerance: FloatTolerance): Matcher[T with Float]

def be (doubleTolerance: DoubleTolerance): Matcher[T with Double]

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

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

def be (resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T with AnyRef]

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

def be (resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T with AnyRef]

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

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

def be (symbol: Symbol): Matcher[T with AnyRef]

def be (resultOfTripleEqualsApplication: ResultOfTripleEqualsApplication): Matcher[T]

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

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

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

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

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

def be (any: Any): Matcher[T]

def clone (): AnyRef

def contain [U] (resultOfValueWordApplication: ResultOfValueWordApplication[U]): Matcher[T with scala.collection.Map[K,U] forSome { type K }]

def contain [U] (resultOfKeyWordApplication: ResultOfKeyWordApplication[U]): Matcher[T with Map[U, Any]]

def contain [U] (expectedElement: U): Matcher[T with Traversable[U]]

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

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

def eq (arg0: AnyRef): Boolean

def equal (any: Any): Matcher[T]

def equals (arg0: Any): Boolean

def finalize (): Unit

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

def getClass (): java.lang.Class[_]

def hashCode (): Int

def have [U] (firstPropertyMatcher: org.scalatest.matchers.HavePropertyMatcher[U, _], propertyMatchers: org.scalatest.matchers.HavePropertyMatcher[U, _]*): Matcher[T with U]

def have (resultOfSizeWordApplication: ResultOfSizeWordApplication): Matcher[T with AnyRef]

def have (resultOfLengthWordApplication: ResultOfLengthWordApplication): Matcher[T with AnyRef]

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

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

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

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

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

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

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

Inherited from AnyRef

Inherited from Any