Packages

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
MatcherFactory4.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(prettifier: Prettifier, pos: Position)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def be(definedWord: DefinedWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Definition]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory and not be defined
                            ^
    

  6. def be(emptyWord: EmptyWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Emptiness]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory and not be empty
                            ^
    

  7. def be(writableWord: WritableWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Writability]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory and not be writable
                            ^
    

  8. def be(readableWord: ReadableWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Readability]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory and not be readable
                            ^
    

  9. def be(sortedWord: SortedWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sortable]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory and not be sorted
                            ^
    

  10. def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax, where fraction is a PartialFunction:

    This method enables the following syntax, where fraction is a PartialFunction:

    aMatcherFactory and not be definedAt (8)
                            ^
    

  11. def be[U](spread: Spread[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be (17.0 +- 0.2)
                            ^
    

  12. def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be theSameInstanceAs (otherString)
                            ^
    

  13. macro def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be an [Apple]
                            ^
    

  14. macro def be(aType: ResultOfATypeInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be a [Book]
                            ^
    

  15. def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4, where invalidMarks is a AnMatcher:

    This method enables the following syntax given a MatcherFactory4, where invalidMarks is a AnMatcher:

    aMatcherFactory and not be an (invalidMarks)
                            ^
    

  16. def be[SC <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[SC]): MatcherFactory4[SC with SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4, where apple is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory4, where apple is a BePropertyMatcher:

    aMatcherFactory and not be an (apple)
                            ^
    

  17. def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be a (directory)
                            ^
    

  18. def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be a (validMarks)
                            ^
    

  19. def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be (directory)
                            ^
    

  20. def be[U](beMatcher: BeMatcher[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be (odd)
                            ^
    

  21. def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

    The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

    Note: usually syntax will be removed after its deprecation period. This was left in because otherwise the syntax could in some cases still compile, but silently wouldn't work.

  22. def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be >= (6)
                            ^
    

  23. def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be <= (2)
                            ^
    

  24. def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory (8) and not be > (6)
                                ^
    

  25. def be(o: Null): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be (null)
                            ^
    

  26. def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be < (6)
                            ^
    

  27. def be(any: Any): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be (3 - 1)
                            ^
    

  28. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  29. def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain atMostOneElementOf (List(8, 1, 2))
                            ^
    

  30. def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  31. def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  32. def contain(right: ResultOfInOrderApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  33. def contain(right: ResultOfAllElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  34. def contain(right: ResultOfAllOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  35. def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  36. def contain(right: ResultOfOnlyApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain only (8, 1, 2)
                            ^
    

  37. def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  38. def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  39. def contain(right: ResultOfNoElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain noElementsOf (8, 1, 2)
                            ^
    

  40. def contain(right: ResultOfNoneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain noneOf (8, 1, 2)
                            ^
    

  41. def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                            ^
    

  42. def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                            ^
    

  43. def contain(right: ResultOfOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  44. def contain(right: ResultOfOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain oneOf (8, 1, 2)
                            ^
    

  45. def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, ValueMapping]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain value (3)
                            ^
    

  46. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, KeyMapping]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain key ("three")
                            ^
    

  47. def contain[U](expectedElement: U): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain (3)
                            ^
    

  48. def endWith(expectedSubstring: String): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not endWith ("1.7")
                            ^
    

  49. def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not endWith regex (decimal)
                            ^
    

  50. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  51. def equal(o: Null): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not equal (null)
                            ^
    

  52. def equal[U](spread: Spread[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not equal (17.0 +- 0.2)
                            ^
    

  53. def equal(any: Any): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Equality]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not equal (3 - 1)
                            ^
    

  54. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  55. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  56. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not fullyMatch regex (decimal)
                            ^
    

  57. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  58. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  59. def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  60. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Messaging]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

  61. def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Size]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not have size (3)
                            ^
    

  62. def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Length]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not have length (3)
                            ^
    

  63. def include(expectedSubstring: String): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not include ("1.7")
                            ^
    

  64. def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not include regex (decimal)
                            ^
    

  65. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  66. macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]

    This method enables the following syntax:

    This method enables the following syntax:

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

  67. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  68. final def notify(): Unit
    Definition Classes
    AnyRef
  69. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  70. val owner: MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    Get the MatcherFactory instance, currently used by macro only.

    Get the MatcherFactory instance, currently used by macro only.

  71. def startWith(expectedSubstring: String): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not startWith ("1.7")
                            ^
    

  72. def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not startWith regex (decimal)
                            ^
    

  73. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  74. def toString(): String
    Definition Classes
    AnyRef → Any
  75. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  76. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  77. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped