Packages

c

org.scalatest.matchers.dsl

ResultOfNotWordForAny

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

Instance Constructors

  1. new ResultOfNotWordForAny(left: T, shouldBeTrue: Boolean, 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[U](definedWord: DefinedWord)(implicit definition: Definition[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    option should not be defined
                     ^

  6. def be[U](emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    list should not be empty
                   ^

  7. def be[U](writableWord: WritableWord)(implicit writability: Writability[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    file should not be writable
                   ^

  8. def be[U](readableWord: ReadableWord)(implicit readability: Readability[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    file should not be readable
                   ^

  9. def be[U](sortedWord: SortedWord)(implicit sortable: Sortable[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    xs should not be sorted
                 ^

  10. def be(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[T, AnyRef]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    otherString should not be theSameInstanceAs (string)
                       ^

  11. def be[U >: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion

    This method enables the following syntax, where keyEvent is, for example, of type KeyEvent and actionKey refers to a BePropertyMatcher[KeyEvent]:

    This method enables the following syntax, where keyEvent is, for example, of type KeyEvent and actionKey refers to a BePropertyMatcher[KeyEvent]:

    keyEvent should not be an (actionKey)
                    ^

  12. def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[T, AnyRef], prettifier: Prettifier, pos: Position): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    keyEvent should not be an ('actionKey)
                    ^

  13. def be[U >: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion

    This method enables the following syntax, where notFileMock is, for example, of type File and file refers to a BePropertyMatcher[File]:

    This method enables the following syntax, where notFileMock is, for example, of type File and file refers to a BePropertyMatcher[File]:

    notFileMock should not be a (file)
                       ^

  14. def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: <:<[T, AnyRef], prettifier: Prettifier, pos: Position): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    notFileMock should not be a ('file)
                       ^

  15. def be(bePropertyMatcher: BePropertyMatcher[T])(implicit ev: <:<[T, AnyRef]): Assertion

    This method enables the following syntax, where stack is, for example, of type Stack and empty refers to a BePropertyMatcher[Stack]:

    This method enables the following syntax, where stack is, for example, of type Stack and empty refers to a BePropertyMatcher[Stack]:

    stack should not be (empty)
                     ^

  16. def be(symbol: Symbol)(implicit toAnyRef: <:<[T, AnyRef], prettifier: Prettifier, pos: Position): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    stack should not be ('empty)
                 ^

  17. def be(o: Null)(implicit ev: <:<[T, AnyRef]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    map should not be (null)
               ^

  18. def be[U](resultOfDefinedAt: ResultOfDefinedAt[U])(implicit ev: <:<[T, PartialFunction[U, _]]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    partialFun should not be definedAt ("apple")
                      ^

  19. def be(spread: Spread[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    sevenDotOh should not be (6.5 +- 0.2)
                      ^

  20. macro def be(anType: ResultOfAnTypeInvocation[_]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be a [Book]
                  ^

  21. macro def be(aType: ResultOfATypeInvocation[_]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be a [Book]
                  ^

  22. def be(resultOfAnWordToAnMatcherApplication: ResultOfAnWordToAnMatcherApplication[T]): Assertion

    This method enables the following syntax, where oddNumber refers to an AnMatcher[Int]:

    This method enables the following syntax, where oddNumber refers to an AnMatcher[Int]:

    2 should not be an (oddNumber)
             ^

  23. def be(resultOfAWordToAMatcherApplication: ResultOfAWordToAMatcherApplication[T]): Assertion

    This method enables the following syntax, where positiveNumber refers to an AMatcher[Int]:

    This method enables the following syntax, where positiveNumber refers to an AMatcher[Int]:

    2 should not be a (positiveNumber)
             ^

  24. def be(beMatcher: BeMatcher[T]): Assertion

    This method enables the following syntax, where odd refers to a BeMatcher[Int]:

    This method enables the following syntax, where odd refers to a BeMatcher[Int]:

    2 should not be (odd)
             ^

  25. def be(comparison: ResultOfGreaterThanComparison[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be > (7)
                  ^

  26. def be(comparison: ResultOfLessThanComparison[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be < (7)
                  ^

  27. def be(comparison: ResultOfGreaterThanOrEqualToComparison[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be >= (7)
                  ^

  28. def be(comparison: ResultOfLessThanOrEqualToComparison[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be <= (7)
                  ^

  29. def be(right: Any): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be (7)
                  ^

  30. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  31. def contain(resultOfValueWordApplication: ResultOfValueWordApplication)(implicit valueMapping: ValueMapping[T]): Assertion
  32. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication)(implicit keyMapping: KeyMapping[T]): Assertion
  33. def contain(atMostOneElementOf: ResultOfAtMostOneElementOfApplication)(implicit aggregating: Aggregating[T]): Assertion
  34. def contain(atMostOneOf: ResultOfAtMostOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion
  35. def contain(only: ResultOfInOrderElementsOfApplication)(implicit sequencing: Sequencing[T]): Assertion
  36. def contain(only: ResultOfInOrderApplication)(implicit sequencing: Sequencing[T]): Assertion
  37. def contain(allElementsOf: ResultOfAllElementsOfApplication)(implicit aggregating: Aggregating[T]): Assertion
  38. def contain(allOf: ResultOfAllOfApplication)(implicit aggregating: Aggregating[T]): Assertion
  39. def contain(only: ResultOfInOrderOnlyApplication)(implicit sequencing: Sequencing[T]): Assertion
  40. def contain(only: ResultOfOnlyApplication)(implicit aggregating: Aggregating[T]): Assertion
  41. def contain(theSameElementsInOrderAs: ResultOfTheSameElementsInOrderAsApplication)(implicit sequencing: Sequencing[T]): Assertion
  42. def contain(theSameElementsAs: ResultOfTheSameElementsAsApplication)(implicit aggregating: Aggregating[T]): Assertion
  43. def contain(noElementsOf: ResultOfNoElementsOfApplication)(implicit containing: Containing[T]): Assertion
  44. def contain(noneOf: ResultOfNoneOfApplication)(implicit containing: Containing[T]): Assertion
  45. def contain(atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication)(implicit aggregating: Aggregating[T]): Assertion
  46. def contain(atLeastOneOf: ResultOfAtLeastOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion
  47. def contain(oneElementOf: ResultOfOneElementOfApplication)(implicit evidence: Containing[T]): Assertion
  48. def contain(newOneOf: ResultOfOneOfApplication)(implicit containing: Containing[T]): Assertion
  49. def contain(expectedElement: Any)(implicit containing: Containing[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    object should not contain ("one")
                  ^

  50. def contain(nullValue: Null)(implicit containing: Containing[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    object should not contain (null)
                  ^

  51. def endWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    "eight" should not endWith ("1.7")
                   ^

  52. def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    greeting should not endWith regex ("wor.d")
                    ^

  53. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  54. def equal(right: Null): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not equal null
                  ^

  55. def equal(spread: Spread[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    sevenDotOh should not equal (6.5 +- 0.2)
                      ^

  56. def equal(right: Any)(implicit equality: Equality[T]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    result should not equal (7)
                  ^

  57. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  58. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  59. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    string should not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
                  ^

    The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

  60. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  61. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  62. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication)(implicit messaging: Messaging[T]): Assertion
  63. def have(firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Assertion

    This method enables the following syntax, where badBook is, for example, of type Book and title ("One Hundred Years of Solitude") results in a HavePropertyMatcher[Book]:

    This method enables the following syntax, where badBook is, for example, of type Book and title ("One Hundred Years of Solitude") results in a HavePropertyMatcher[Book]:

    book should not have (title ("One Hundred Years of Solitude"))
                ^

  64. def have(resultOfSizeWordApplication: ResultOfSizeWordApplication)(implicit sz: Size[T]): Assertion

    Enables parentheses to be placed around size (N) in expressions of the form: should not have (size (N)).

  65. def have(resultOfLengthWordApplication: ResultOfLengthWordApplication)(implicit len: Length[T]): Assertion

    Enables parentheses to be placed around length (N) in expressions of the form: should not have (length (N)).

  66. def include(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    string should not include ("world")
                  ^

  67. def include(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    string should not include regex ("wo.ld")
                  ^

    The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

  68. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  69. val left: T
  70. macro def matchPattern(right: PartialFunction[Any, _]): Unit

    This method enables the following syntax:

    This method enables the following syntax:

    result should not matchPattern { case Person("Bob", _) => }
                  ^

  71. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  72. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  73. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  74. val pos: Position
  75. val prettifier: Prettifier
  76. val shouldBeTrue: Boolean
  77. def startWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    "eight" should not startWith ("1.7")
                   ^

  78. def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Assertion

    This method enables the following syntax:

    This method enables the following syntax:

    string should not startWith regex ("Hel*o")
                  ^

    The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

  79. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  80. def toString(): String

    Overrides toString to return pretty text.

    Overrides toString to return pretty text.

    Definition Classes
    ResultOfNotWordForAny → AnyRef → Any
  81. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  82. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  83. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Deprecated Value Members

  1. def be(comparison: TripleEqualsInvocation[_]): Matcher[Any]

    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.

    Annotations
    @deprecated
    Deprecated

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

Inherited from AnyRef

Inherited from Any

Ungrouped