scalatestMatchersCoreDotty
API
Generated with
scalatestMatchersCoreDotty/org.scalatest.matchers/Matcher/AndNotWord

AndNotWord

org.scalatest.matchers.Matcher.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.

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type

Members list

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

infix def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not be === (6)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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]
                ^

Attributes

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]
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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
                ^

Attributes

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
                ^

Attributes

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
                ^

Attributes

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
                ^

Attributes

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
                ^

Attributes

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)
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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))
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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))
                ^

Attributes

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)
                        ^

Attributes

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))
                        ^

Attributes

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")
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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")
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

infix def equal(o: Null): Matcher[T]

This method enables the following syntax:

This method enables the following syntax:

aMatcher and not equal (null)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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)
                ^

Attributes

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!")
                ^

Attributes

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"))
                ^

Attributes

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)
                ^

Attributes

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")
                ^

Attributes

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", _) =>}
                ^

Attributes

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)
                ^

Attributes

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")
                ^

Attributes

Concrete fields

val owner: Matcher[T]

Get the Matcher instance, currently used by macro only.

Get the Matcher instance, currently used by macro only.

Attributes

Generated with