scalatestMatchersCoreDotty/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

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

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be (3 - 1)
                ^
infix 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)
                ^
infix def be(o: Null): Matcher[T & AnyRef]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be (null)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be ('empty)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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]
                ^
infix 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]
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix def be(sortedWord: SortedWord): MatcherFactory1[T, Sortable]

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

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

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be defined
                ^
infix 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)
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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))
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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))
                ^
infix 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)
                        ^
infix 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))
                        ^
infix 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")
                ^
infix 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)
                ^
infix 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)
                ^
infix 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")
                ^
infix 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)
                ^
infix 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)
                ^
infix def equal(o: Null): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not equal (null)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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)
                ^
infix 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!")
                ^
infix 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"))
                ^
infix 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)
                ^
infix 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")
                ^
infix 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", _) =>}
                ^
infix 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)
                ^
infix 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.