Class

org.scalatest.matchers.MatcherFactory6

OrNotWord

Related Doc: package MatcherFactory6

Permalink

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

Instance Constructors

  1. new OrNotWord(prettifier: Prettifier, pos: Position)

    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): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Definition]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be defined
                           ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be empty
                           ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be writable
                           ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be readable
                           ^
    

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

    Permalink

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

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

    aMatcherFactory or not be sorted
                           ^
    

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

    Permalink

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

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

    aMatcherFactory or not be definedAt (8)
                           ^
    

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

    Permalink

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

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

    aMatcherFactory or not be (17.0 +- 0.2)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be theSameInstanceAs (string)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be an [Apple]
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be a [Book]
                           ^
    

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

    Permalink

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

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

    aMatcherFactory and not be an (invalidMarks)
                            ^
    

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

    Permalink

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

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

    aMatcherFactory or not be an (apple)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    aMatcherFactory or not be a (file)
                           ^
    

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

    Permalink

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

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

    aMatcherFactory or not be a (validMarks)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    aMatcherFactory or not be (file)
                           ^
    

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

    Permalink

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

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

    aMatcherFactory or not be (odd)
                           ^
    

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

    Permalink

    The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

    The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. 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]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be >= (6)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be <= (2)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be > (6)
                           ^
    

  25. def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be < (8)
                           ^
    

  26. def be(o: Null): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be (null)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be (2)
                           ^
    

  28. def clone(): AnyRef

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain inOrderElementsOf (8, 1, 2)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain atLeastOneElementOf (8, 1, 2)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain value (3)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain key ("three")
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain (3)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not endWith ("1.7")
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not endWith regex (decimal)
                           ^
    

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

    Permalink
    Definition Classes
    AnyRef
  51. def equal(o: Null): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not equal (null)
                           ^
    

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

    Permalink

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

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

    aMatcherFactory or not equal (17.0 +- 0.2)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not equal (3 - 1)
                           ^
    

  54. def equals(arg0: Any): Boolean

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

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  56. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not fullyMatch regex (decimal)
                           ^
    

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

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

    Permalink
    Definition Classes
    AnyRef → Any
  59. def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

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

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not have size (3)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not have length (3)
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not include ("1.7")
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not include regex (decimal)
                           ^
    

  65. final def isInstanceOf[T0]: Boolean

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

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

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

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

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

    Permalink
    Definition Classes
    AnyRef
  70. val owner: MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    Permalink

    Get the MatcherFactory instance, currently used by macro.

    Get the MatcherFactory instance, currently used by macro.

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not startWith ("1.7")
                           ^
    

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

    Permalink

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not startWith regex (decimal)
                           ^
    

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

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

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

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

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

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

Inherited from AnyRef

Inherited from Any

Ungrouped