AndNotWord

final class AndNotWord 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: MatcherFactory3.scala

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

AndNotWord
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Instance Constructors

new AndNotWord(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(definedWord: DefinedWord): MatcherFactory4[SC, TC1, TC2, TC3, Definition]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be defined
                        ^
```
def be(emptyWord: EmptyWord): MatcherFactory4[SC, TC1, TC2, TC3, Emptiness]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be empty
                        ^
```
def be(writableWord: WritableWord): MatcherFactory4[SC, TC1, TC2, TC3, Writability]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be writable
                        ^
```
def be(readableWord: ReadableWord): MatcherFactory4[SC, TC1, TC2, TC3, Readability]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be readable
                        ^
```
def be(sortedWord: SortedWord): MatcherFactory4[SC, TC1, TC2, TC3, Sortable]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be sorted
                        ^
```
def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax, where fraction is a PartialFunction:
This method enables the following syntax, where fraction is a PartialFunction:
```
aMatcherFactory and not be definedAt (8)
                        ^
```
def be[U](spread: Spread[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax, for the "primitive" numeric types:
This method enables the following syntax, for the "primitive" numeric types:
```
aMatcherFactory and not be (17.0 +- 0.2)
                        ^
```
def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be theSameInstanceAs (otherString)
                        ^
```
macro def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be an [Apple]
                        ^
```
macro def be(aType: ResultOfATypeInvocation[_]): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be a [Book]
                        ^
```
def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where invalidMarks is a AnMatcher:
This method enables the following syntax given a MatcherFactory3, where invalidMarks is a AnMatcher:
```
aMatcherFactory and not be an (invalidMarks)
                        ^
```
def be[SC <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[SC]): MatcherFactory3[SC with SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where apple is a BePropertyMatcher:
This method enables the following syntax given a MatcherFactory3, where apple is a BePropertyMatcher:
```
aMatcherFactory and not be an (apple)
                        ^
```
def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
```
aMatcherFactory and not be a (directory)
                        ^
```
def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where validMarks is an AMatcher:
This method enables the following syntax given a MatcherFactory3, where validMarks is an AMatcher:
```
aMatcherFactory and not be a (validMarks)
                        ^
```
def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
```
aMatcherFactory and not be (directory)
                        ^
```
def be[U](beMatcher: BeMatcher[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where odd is a BeMatcher:
This method enables the following syntax given a MatcherFactory3, where odd is a BeMatcher:
```
aMatcherFactory and not be (odd)
                        ^
```
def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory3[SC, TC1, TC2, TC3]
The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.
The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. 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.
def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be >= (6)
                        ^
```
def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be <= (2)
                        ^
```
def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory (8) and not be > (6)
                            ^
```
def be(o: Null): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be (null)
                        ^
```
def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be < (6)
                        ^
```
def be(any: Any): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be (3 - 1)
                        ^
```
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atMostOneElementOf (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atMostOneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain inOrder (8, 1, 2)
                        ^
```
def contain(right: ResultOfInOrderApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain inOrder (8, 1, 2)
                        ^
```
def contain(right: ResultOfAllElementsOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain allElementsOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfAllOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain allOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain inOrderOnly (8, 1, 2)
                        ^
```
def contain(right: ResultOfOnlyApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain only (8, 1, 2)
                        ^
```
def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain theSameElementsInOrderAs (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain theSameElementsAs (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfNoElementsOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain noElementsOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfNoneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain noneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfOneElementOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain oneElementOf (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfOneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain oneOf (8, 1, 2)
                        ^
```
def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, ValueMapping]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain value (3)
                        ^
```
def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, KeyMapping]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain key ("three")
                        ^
```
def contain[U](expectedElement: U): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain (3)
                        ^
```
def endWith(expectedSubstring: String): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not endWith ("1.7")
                        ^
```
def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not endWith regex (decimal)
                        ^
```
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(o: Null): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not equal (null)
                        ^
```
def equal[U](spread: Spread[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax, for the "primitive" numeric types:
This method enables the following syntax, for the "primitive" numeric types:
```
aMatcherFactory and not equal (17.0 +- 0.2)
                        ^
```
def equal(any: Any): MatcherFactory4[SC, TC1, TC2, TC3, Equality]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not equal (3 - 1)
                        ^
```
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): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not fullyMatch regex (decimal)
                        ^
```
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have (author ("Melville"))
                        ^
```
def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, Messaging]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have message ("Message from Mars!")
                        ^
```
def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, Size]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have size (3)
                        ^
```
def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, Length]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have length (3)
                        ^
```
def include(expectedSubstring: String): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not include ("1.7")
                        ^
```
def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not include regex (decimal)
                        ^
```
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and 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 owner: MatcherFactory3[SC, TC1, TC2, TC3]
Get the MatcherFactory instance, currently used by macro only.
Get the MatcherFactory instance, currently used by macro only.
def startWith(expectedSubstring: String): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not startWith ("1.7")
                        ^
```
def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not startWith regex (decimal)
                        ^
```
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
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( ... )

Inherited from AnyRef

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 clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
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] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
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( ... )

Inherited from Any

Value Members

final def asInstanceOf[T0]: T0

Definition Classes
Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any

Ungrouped

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(definedWord: DefinedWord): MatcherFactory4[SC, TC1, TC2, TC3, Definition]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be defined
                        ^
```
def be(emptyWord: EmptyWord): MatcherFactory4[SC, TC1, TC2, TC3, Emptiness]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be empty
                        ^
```
def be(writableWord: WritableWord): MatcherFactory4[SC, TC1, TC2, TC3, Writability]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be writable
                        ^
```
def be(readableWord: ReadableWord): MatcherFactory4[SC, TC1, TC2, TC3, Readability]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be readable
                        ^
```
def be(sortedWord: SortedWord): MatcherFactory4[SC, TC1, TC2, TC3, Sortable]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not be sorted
                        ^
```
def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax, where fraction is a PartialFunction:
This method enables the following syntax, where fraction is a PartialFunction:
```
aMatcherFactory and not be definedAt (8)
                        ^
```
def be[U](spread: Spread[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax, for the "primitive" numeric types:
This method enables the following syntax, for the "primitive" numeric types:
```
aMatcherFactory and not be (17.0 +- 0.2)
                        ^
```
def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be theSameInstanceAs (otherString)
                        ^
```
macro def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be an [Apple]
                        ^
```
macro def be(aType: ResultOfATypeInvocation[_]): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be a [Book]
                        ^
```
def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where invalidMarks is a AnMatcher:
This method enables the following syntax given a MatcherFactory3, where invalidMarks is a AnMatcher:
```
aMatcherFactory and not be an (invalidMarks)
                        ^
```
def be[SC <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[SC]): MatcherFactory3[SC with SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where apple is a BePropertyMatcher:
This method enables the following syntax given a MatcherFactory3, where apple is a BePropertyMatcher:
```
aMatcherFactory and not be an (apple)
                        ^
```
def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
```
aMatcherFactory and not be a (directory)
                        ^
```
def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where validMarks is an AMatcher:
This method enables the following syntax given a MatcherFactory3, where validMarks is an AMatcher:
```
aMatcherFactory and not be a (validMarks)
                        ^
```
def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
This method enables the following syntax given a MatcherFactory3, where directory is a BePropertyMatcher:
```
aMatcherFactory and not be (directory)
                        ^
```
def be[U](beMatcher: BeMatcher[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3, where odd is a BeMatcher:
This method enables the following syntax given a MatcherFactory3, where odd is a BeMatcher:
```
aMatcherFactory and not be (odd)
                        ^
```
def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory3[SC, TC1, TC2, TC3]
The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.
The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. 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.
def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be >= (6)
                        ^
```
def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be <= (2)
                        ^
```
def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory (8) and not be > (6)
                            ^
```
def be(o: Null): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be (null)
                        ^
```
def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be < (6)
                        ^
```
def be(any: Any): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not be (3 - 1)
                        ^
```
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atMostOneElementOf (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atMostOneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain inOrder (8, 1, 2)
                        ^
```
def contain(right: ResultOfInOrderApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain inOrder (8, 1, 2)
                        ^
```
def contain(right: ResultOfAllElementsOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain allElementsOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfAllOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain allOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain inOrderOnly (8, 1, 2)
                        ^
```
def contain(right: ResultOfOnlyApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain only (8, 1, 2)
                        ^
```
def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory4[SC, TC1, TC2, TC3, Sequencing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain theSameElementsInOrderAs (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain theSameElementsAs (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfNoElementsOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain noElementsOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfNoneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain noneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Aggregating]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                        ^
```
def contain(right: ResultOfOneElementOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain oneElementOf (List(8, 1, 2))
                        ^
```
def contain(right: ResultOfOneOfApplication): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain oneOf (8, 1, 2)
                        ^
```
def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, ValueMapping]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain value (3)
                        ^
```
def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, KeyMapping]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain key ("three")
                        ^
```
def contain[U](expectedElement: U): MatcherFactory4[SC, TC1, TC2, TC3, Containing]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not contain (3)
                        ^
```
def endWith(expectedSubstring: String): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not endWith ("1.7")
                        ^
```
def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not endWith regex (decimal)
                        ^
```
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(o: Null): MatcherFactory3[SC, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not equal (null)
                        ^
```
def equal[U](spread: Spread[U]): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax, for the "primitive" numeric types:
This method enables the following syntax, for the "primitive" numeric types:
```
aMatcherFactory and not equal (17.0 +- 0.2)
                        ^
```
def equal(any: Any): MatcherFactory4[SC, TC1, TC2, TC3, Equality]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not equal (3 - 1)
                        ^
```
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): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not fullyMatch regex (decimal)
                        ^
```
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory3[SC with U, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have (author ("Melville"))
                        ^
```
def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, Messaging]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have message ("Message from Mars!")
                        ^
```
def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, Size]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have size (3)
                        ^
```
def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory4[SC, TC1, TC2, TC3, Length]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not have length (3)
                        ^
```
def include(expectedSubstring: String): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not include ("1.7")
                        ^
```
def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not include regex (decimal)
                        ^
```
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and 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 owner: MatcherFactory3[SC, TC1, TC2, TC3]
Get the MatcherFactory instance, currently used by macro only.
Get the MatcherFactory instance, currently used by macro only.
def startWith(expectedSubstring: String): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not startWith ("1.7")
                        ^
```
def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory3[SC with String, TC1, TC2, TC3]
This method enables the following syntax given a MatcherFactory3:
This method enables the following syntax given a MatcherFactory3:
```
aMatcherFactory and not startWith regex (decimal)
                        ^
```
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
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( ... )

Packages

AndNotWord 

final class AndNotWord extends AnyRef

Instance Constructors

Value Members

Inherited from AnyRef

Value Members

Inherited from Any

Value Members

Ungrouped

AndNotWord