Class

org.scalatest.matchers.dsl

ResultOfNotWordForAny

Related Doc: package dsl

Permalink

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)

    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[U](definedWord: DefinedWord)(implicit definition: Definition[T]): Assertion

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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

    Permalink

    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[U >: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion

    Permalink

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

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

    Permalink

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

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    map should not be (null)
                   ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    partialFun should not be definedAt ("apple")
                          ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    sevenDotOh should not be (6.5 +- 0.2)
                          ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be a [Book]
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be a [Book]
                      ^
    

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

    Permalink

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

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

    Permalink

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

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

    Permalink

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

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be > (7)
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be < (7)
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be >= (7)
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be <= (7)
                      ^
    

  26. def be(right: Any): Assertion

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not be (7)
                      ^
    

  27. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  28. def contain(resultOfValueWordApplication: ResultOfValueWordApplication)(implicit valueMapping: ValueMapping[T]): Assertion

    Permalink
  29. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication)(implicit keyMapping: KeyMapping[T]): Assertion

    Permalink
  30. def contain(atMostOneElementOf: ResultOfAtMostOneElementOfApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  31. def contain(atMostOneOf: ResultOfAtMostOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  32. def contain(only: ResultOfInOrderElementsOfApplication)(implicit sequencing: Sequencing[T]): Assertion

    Permalink
  33. def contain(only: ResultOfInOrderApplication)(implicit sequencing: Sequencing[T]): Assertion

    Permalink
  34. def contain(allElementsOf: ResultOfAllElementsOfApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  35. def contain(allOf: ResultOfAllOfApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  36. def contain(only: ResultOfInOrderOnlyApplication)(implicit sequencing: Sequencing[T]): Assertion

    Permalink
  37. def contain(only: ResultOfOnlyApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  38. def contain(theSameElementsInOrderAs: ResultOfTheSameElementsInOrderAsApplication)(implicit sequencing: Sequencing[T]): Assertion

    Permalink
  39. def contain(theSameElementsAs: ResultOfTheSameElementsAsApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  40. def contain(noElementsOf: ResultOfNoElementsOfApplication)(implicit containing: Containing[T]): Assertion

    Permalink
  41. def contain(noneOf: ResultOfNoneOfApplication)(implicit containing: Containing[T]): Assertion

    Permalink
  42. def contain(atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  43. def contain(atLeastOneOf: ResultOfAtLeastOneOfApplication)(implicit aggregating: Aggregating[T]): Assertion

    Permalink
  44. def contain(oneElementOf: ResultOfOneElementOfApplication)(implicit evidence: Containing[T]): Assertion

    Permalink
  45. def contain(newOneOf: ResultOfOneOfApplication)(implicit containing: Containing[T]): Assertion

    Permalink
  46. def contain(expectedElement: Any)(implicit containing: Containing[T]): Assertion

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    object should not contain ("one")
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    object should not contain (null)
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    Permalink
    Definition Classes
    AnyRef
  51. def equal(right: Null): Assertion

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not equal null
                      ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    sevenDotOh should not equal (6.5 +- 0.2)
                          ^
    

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should not equal (7)
                      ^
    

  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)(implicit ev: <:<[T, String]): Assertion

    Permalink

    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.

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

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

    Permalink
    Definition Classes
    AnyRef → Any
  59. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication)(implicit messaging: Messaging[T]): Assertion

    Permalink
  60. def have(firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Assertion

    Permalink

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

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

    Permalink

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

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

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

    Permalink

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

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

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    string should not include ("world")
                      ^
    

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

    Permalink

    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.

  65. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  66. val left: T

    Permalink
  67. macro def matchPattern(right: PartialFunction[Any, _]): Unit

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

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

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

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

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

    Permalink
    Definition Classes
    AnyRef
  71. val pos: Position

    Permalink
  72. val prettifier: Prettifier

    Permalink
  73. val shouldBeTrue: Boolean

    Permalink
  74. def startWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Assertion

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    Permalink

    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.

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

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

    Permalink

    Overrides toString to return pretty text.

    Overrides toString to return pretty text.

    Definition Classes
    ResultOfNotWordForAny → 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( ... )

Deprecated Value Members

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

    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.

    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