org.scalatest.matchers.Matcher

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.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. AndNotWord
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new AndNotWord()

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

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

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. final def asInstanceOf[T0]: T0

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be defined
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be empty
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be writable
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be readable
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be sorted
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be definedAt (8)
                     ^
    

  13. def be[U](spread: Spread[U]): Matcher[T with 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)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be theSameInstanceAs (otherString)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be an [Apple]
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be a [Book]
                     ^
    

  17. def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with 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)
                     ^
    

  18. def be[T <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[T]): Matcher[T with 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)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be an ('apple)
                     ^
    

  20. def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T with 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)
                     ^
    

  21. def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with 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)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be a ('file)
                     ^
    

  23. def be[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with 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)
                     ^
    

  24. def be[U](beMatcher: BeMatcher[U]): Matcher[T with 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)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be ('empty)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be === (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be >= (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be <= (2)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be > (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be (null)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be < (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be (3 - 1)
                     ^
    

  33. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  34. 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)
                     ^
    

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

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

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

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

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

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

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

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

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

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

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

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

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not endWith ("1.7")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not endWith regex (decimal)
                     ^
    

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

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not equal (null)
                     ^
    

  51. def equal[U](spread: Spread[U]): Matcher[T with 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)
                     ^
    

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

  53. def equals(arg0: Any): Boolean

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

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not fullyMatch regex (decimal)
                     ^
    

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

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

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

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

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

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not include ("1.7")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not include regex (decimal)
                     ^
    

  64. final def isInstanceOf[T0]: Boolean

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

    Definition Classes
    AnyRef
  66. final def notify(): Unit

    Definition Classes
    AnyRef
  67. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  68. def startWith(expectedSubstring: String): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not startWith ("1.7")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not startWith regex (decimal)
                     ^
    

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

    Definition Classes
    AnyRef
  71. def toString(): String

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

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws()

Inherited from AnyRef

Inherited from Any

Ungrouped