Class

org.scalatest.matchers.Matcher

AndNotWord

Related Doc: package Matcher

Permalink

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
Matcher.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AndNotWord
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new AndNotWord()

    Permalink

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  5. def be(definedWord: DefinedWord): MatcherFactory1[T, Definition]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be defined
                     ^
    

  6. def be(emptyWord: EmptyWord): MatcherFactory1[T, Emptiness]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be empty
                     ^
    

  7. def be(writableWord: WritableWord): MatcherFactory1[T, Writability]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be writable
                     ^
    

  8. def be(readableWord: ReadableWord): MatcherFactory1[T, Readability]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be readable
                     ^
    

  9. def be(sortedWord: SortedWord): MatcherFactory1[T, Sortable]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be sorted
                     ^
    

  10. def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[T with U]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be definedAt (8)
                     ^
    

  11. def be[U](spread: Spread[U]): Matcher[T with U]

    Permalink

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

  12. def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be theSameInstanceAs (otherString)
                     ^
    

  13. macro def be(anType: ResultOfAnTypeInvocation[_]): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be an [Apple]
                     ^
    

  14. macro def be(aType: ResultOfATypeInvocation[_]): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be a [Book]
                     ^
    

  15. def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with U]

    Permalink

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

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

    Permalink

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

  17. def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be an ('apple)
                     ^
    

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

    Permalink

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

  19. def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with U]

    Permalink

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

  20. def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be a ('file)
                     ^
    

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

    Permalink

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

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

    Permalink

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

  23. def be(symbol: Symbol): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be ('empty)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be === (6)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be >= (6)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be <= (2)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be > (6)
                     ^
    

  28. def be(o: Null): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be (null)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be < (6)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be (3 - 1)
                     ^
    

  31. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  32. def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[T, ValueMapping]

    Permalink

    This method enables the following syntax given a Matcher:

    This method enables the following syntax given a Matcher:

    aMatcher and not contain value (3)
                     ^
    

  33. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping]

    Permalink

    This method enables the following syntax given a Matcher:

    This method enables the following syntax given a Matcher:

    aMatcher and not contain key ("three")
                     ^
    

  34. def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain atMostOneOf (List(8, 1, 2))
                             ^
    

  35. def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain atMostOneOf (8, 1, 2)
                             ^
    

  36. def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory1[T, Sequencing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain inOrderElementsOf (List(8, 1, 2))
                     ^
    

  37. def contain(right: ResultOfInOrderApplication): MatcherFactory1[T, Sequencing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain inOrder (8, 1, 2)
                     ^
    

  38. def contain(right: ResultOfAllElementsOfApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain allElementsOf (8, 1, 2)
                     ^
    

  39. def contain(right: ResultOfAllOfApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain allOf (8, 1, 2)
                     ^
    

  40. def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory1[T, Sequencing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain inOrderOnly (8, 1, 2)
                     ^
    

  41. def contain(right: ResultOfOnlyApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain only (List(8, 1, 2))
                     ^
    

  42. def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[T, Sequencing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain theSameElementsInOrderAs (List(8, 1, 2))
                     ^
    

  43. def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain theSameElementsAs (List(8, 1, 2))
                     ^
    

  44. def contain(right: ResultOfNoElementsOfApplication): MatcherFactory1[T, Containing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain noElementsOf (List(8, 1, 2))
                     ^
    

  45. def contain(right: ResultOfNoneOfApplication): MatcherFactory1[T, Containing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain noneOf (List(8, 1, 2))
                     ^
    

  46. def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain atLeastOneElementOf (List(8, 1, 2))
                     ^
    

  47. def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory1[T, Aggregating]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain atLeastOneOf (List(8, 1, 2))
                     ^
    

  48. def contain(right: ResultOfOneElementOfApplication): MatcherFactory1[T, Containing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain oneElementOf (List(8, 1, 2))
                     ^
    

  49. def contain(right: ResultOfOneOfApplication): MatcherFactory1[T, Containing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain oneOf (List(8, 1, 2))
                     ^
    

  50. def contain[U](expectedElement: U): MatcherFactory1[T, Containing]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain (3)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not endWith ("1.7")
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not endWith regex (decimal)
                     ^
    

  53. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  54. def equal(o: Null): Matcher[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not equal (null)
                     ^
    

  55. def equal[U](spread: Spread[U]): Matcher[T with U]

    Permalink

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

  56. def equal(any: Any): MatcherFactory1[T, Equality]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not equal (3 - 1)
                     ^
    

  57. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  58. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  59. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not fullyMatch regex (decimal)
                     ^
    

  60. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  61. def hashCode(): Int

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have (author ("Melville"))
                     ^
    

  63. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[T, Messaging]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have message ("Message from Mars!")
                     ^
    

  64. def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[T, Size]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have size (3)
                     ^
    

  65. def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[T, Length]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have length (3)
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not include ("1.7")
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not include regex (decimal)
                     ^
    

  68. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  69. macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not matchPattern { case Person("Bob", _) =>}
                     ^
    

  70. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  71. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  72. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  73. val owner: Matcher[T]

    Permalink

    Get the Matcher instance, currently used by macro only.

    Get the Matcher instance, currently used by macro only.

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not startWith ("1.7")
                     ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not startWith regex (decimal)
                     ^
    

  76. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  77. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  78. final def wait(): Unit

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

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  80. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped