scalatestMatchersCoreDottyNative/org.scalatest.matchers/Matcher/AndNotWord

AndNotWord

final class AndNotWord

This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

class Object
trait Matchable
class Any

Value members

Concrete methods

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

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be (3 - 1)
                ^
def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): Matcher[T & U]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be < (6)
                ^
def be(o: Null): Matcher[T & AnyRef]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be (null)
                ^
def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): Matcher[T & U]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be > (6)
                ^
def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): Matcher[T & U]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be <= (2)
                ^
def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): Matcher[T & U]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be >= (6)
                ^
def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be === (6)
                ^
def be(symbol: Symbol): Matcher[T & AnyRef]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be ('empty)
                ^
def be[U](beMatcher: BeMatcher[U]): Matcher[T & U]

This method enables the following syntax, where odd is a BeMatcher:

This method enables the following syntax, where odd is a BeMatcher:

aMatcher and not be (odd)
                ^
def be[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T & AnyRef & U]

This method enables the following syntax, where directory is a BePropertyMatcher:

This method enables the following syntax, where directory is a BePropertyMatcher:

aMatcher and not be (directory)
                ^
def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T & AnyRef]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be a ('file)
                ^
def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T & U]

This method enables the following syntax, where validMarks is an AMatcher:

This method enables the following syntax, where validMarks is an AMatcher:

aMatcher and not be a (validMarks)
                ^
def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T & U]

This method enables the following syntax, where directory is a BePropertyMatcher:

This method enables the following syntax, where directory is a BePropertyMatcher:

aMatcher and not be a (directory)
                ^
def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T & AnyRef]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be an ('apple)
                ^
def be[T <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[T]): Matcher[T & T]

This method enables the following syntax, where directory is a BePropertyMatcher:

This method enables the following syntax, where directory is a BePropertyMatcher:

aMatcher and not be an (directory)
                ^
def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T & U]

This method enables the following syntax, where invalidMarks is an AnMatcher:

This method enables the following syntax, where invalidMarks is an AnMatcher:

aMatcher and not be an (invalidMarks)
                ^
inline def be(aType: ResultOfATypeInvocation[_]): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be a [Book]
                ^
inline def be(anType: ResultOfAnTypeInvocation[_]): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be an [Apple]
                ^
def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T & AnyRef]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be theSameInstanceAs (otherString)
                ^
def be[U](spread: Spread[U]): Matcher[T & U]

This method enables the following syntax, for the "primitive" numeric types:

This method enables the following syntax, for the "primitive" numeric types:

aMatcher and not be (17.0 +- 0.2)
                ^
def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[T & U]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be definedAt (8)
                ^
def be(sortedWord: SortedWord): MatcherFactory1[T, Sortable]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be sorted
                ^
def be(readableWord: ReadableWord): MatcherFactory1[T, Readability]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be readable
                ^
def be(writableWord: WritableWord): MatcherFactory1[T, Writability]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be writable
                ^
def be(emptyWord: EmptyWord): MatcherFactory1[T, Emptiness]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be empty
                ^
def be(definedWord: DefinedWord): MatcherFactory1[T, Definition]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be defined
                ^
def contain[U](expectedElement: U): MatcherFactory1[T, Containing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain (3)
                ^
def contain(right: ResultOfOneOfApplication): MatcherFactory1[T, Containing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain oneOf (List(8, 1, 2))
                ^
def contain(right: ResultOfOneElementOfApplication): MatcherFactory1[T, Containing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain oneElementOf (List(8, 1, 2))
                ^
def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain atLeastOneOf (List(8, 1, 2))
                ^
def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain atLeastOneElementOf (List(8, 1, 2))
                ^
def contain(right: ResultOfNoneOfApplication): MatcherFactory1[T, Containing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain noneOf (List(8, 1, 2))
                ^
def contain(right: ResultOfNoElementsOfApplication): MatcherFactory1[T, Containing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain noElementsOf (List(8, 1, 2))
                ^
def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain theSameElementsAs (List(8, 1, 2))
                ^
def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[T, Sequencing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain theSameElementsInOrderAs (List(8, 1, 2))
                ^
def contain(right: ResultOfOnlyApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain only (List(8, 1, 2))
                ^
def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory1[T, Sequencing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain inOrderOnly (8, 1, 2)
                ^
def contain(right: ResultOfAllOfApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain allOf (8, 1, 2)
                ^
def contain(right: ResultOfAllElementsOfApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain allElementsOf (8, 1, 2)
                ^
def contain(right: ResultOfInOrderApplication): MatcherFactory1[T, Sequencing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain inOrder (8, 1, 2)
                ^
def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory1[T, Sequencing]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain inOrderElementsOf (List(8, 1, 2))
                ^
def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain atMostOneOf (8, 1, 2)
                        ^
def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory1[T, Aggregating]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not contain atMostOneOf (List(8, 1, 2))
                        ^
def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping]

This method enables the following syntax given a Matcher:

This method enables the following syntax given a Matcher:

aMatcher and not contain key ("three")
                ^
def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[T, ValueMapping]

This method enables the following syntax given a Matcher:

This method enables the following syntax given a Matcher:

aMatcher and not contain value (3)
                ^
def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not endWith regex (decimal)
                ^
def endWith(expectedSubstring: String): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not endWith ("1.7")
                ^
def equal(any: Any): MatcherFactory1[T, Equality]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not equal (3 - 1)
                ^
def equal[U](spread: Spread[U]): Matcher[T & U]

This method enables the following syntax, for the "primitive" numeric types:

This method enables the following syntax, for the "primitive" numeric types:

aMatcher and not equal (17.0 +- 0.2)
                ^
def equal(o: Null): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not equal (null)
                ^
def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not fullyMatch regex (decimal)
                ^
def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[T, Length]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not have length (3)
                ^
def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[T, Size]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not have size (3)
                ^
def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[T, Messaging]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not have message ("Message from Mars!")
                ^
def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): Matcher[T & U]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not have (author ("Melville"))
                ^
def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not include regex (decimal)
                ^
def include(expectedSubstring: String): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not include ("1.7")
                ^
inline def matchPattern(inline right: PartialFunction[Any, _]): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not matchPattern { case Person("Bob", _) =>}
                ^
def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not startWith regex (decimal)
                ^
def startWith(expectedSubstring: String): Matcher[T & String]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not startWith ("1.7")
                ^

Concrete fields

val owner: Matcher[T]

Get the Matcher instance, currently used by macro only.

Get the Matcher instance, currently used by macro only.