org.scalatest.words

FactResultOfNotWordForAny

final class FactResultOfNotWordForAny[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.

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

Instance Constructors

  1. new FactResultOfNotWordForAny(left: T, willBeTrue: Boolean, prettifier: Prettifier, pos: Position)

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

    This method enables the following syntax:

    This method enables the following syntax:

    option will not be defined
                         ^
    

  8. def be[U](emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    list will not be empty
                       ^
    

  9. def be[U](writableWord: WritableWord)(implicit writability: Writability[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    file will not be writable
                       ^
    

  10. def be[U](readableWord: ReadableWord)(implicit readability: Readability[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    file will not be readable
                       ^
    

  11. def be[U](sortedWord: SortedWord)(implicit sortable: Sortable[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    xs will not be sorted
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    otherString will not be theSameInstanceAs (string)
                           ^
    

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

    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 will not be an (actionKey)
                        ^
    

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

    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 will not be a (file)
                           ^
    

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

    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 will not be (empty)
                         ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    map will not be (null)
                   ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    partialFun will not be definedAt ("apple")
                          ^
    

  18. def be(spread: Spread[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    sevenDotOh will not be (6.5 +- 0.2)
                          ^
    

  19. def be(anType: FactResultOfAnTypeInvocation[_]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be a [Book]
                      ^
    

    Annotations
    @macroImpl( ... )
  20. def be(aType: FactResultOfATypeInvocation[_]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be a [Book]
                      ^
    

    Annotations
    @macroImpl( ... )
  21. def be(resultOfAnWordToAnMatcherApplication: ResultOfAnWordToAnMatcherApplication[T]): Fact

    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 will not be an (oddNumber)
                 ^
    

  22. def be(resultOfAWordToAMatcherApplication: ResultOfAWordToAMatcherApplication[T]): Fact

    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 will not be a (positiveNumber)
                 ^
    

  23. def be(beMatcher: BeMatcher[T]): Fact

    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 will not be (odd)
                 ^
    

  24. def be(comparison: ResultOfGreaterThanComparison[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be > (7)
                      ^
    

  25. def be(comparison: ResultOfLessThanComparison[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be < (7)
                      ^
    

  26. def be(comparison: ResultOfGreaterThanOrEqualToComparison[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be >= (7)
                      ^
    

  27. def be(comparison: ResultOfLessThanOrEqualToComparison[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be <= (7)
                      ^
    

  28. def be(right: Any): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not be (7)
                      ^
    

  29. def clone(): AnyRef

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

  31. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication)(implicit keyMapping: KeyMapping[T]): Fact

  32. def contain(atMostOneElementOf: ResultOfAtMostOneElementOfApplication)(implicit aggregating: Aggregating[T]): Fact

  33. def contain(atMostOneOf: ResultOfAtMostOneOfApplication)(implicit aggregating: Aggregating[T]): Fact

  34. def contain(only: ResultOfInOrderElementsOfApplication)(implicit sequencing: Sequencing[T]): Fact

  35. def contain(only: ResultOfInOrderApplication)(implicit sequencing: Sequencing[T]): Fact

  36. def contain(allElementsOf: ResultOfAllElementsOfApplication)(implicit aggregating: Aggregating[T]): Fact

  37. def contain(allOf: ResultOfAllOfApplication)(implicit aggregating: Aggregating[T]): Fact

  38. def contain(only: ResultOfInOrderOnlyApplication)(implicit sequencing: Sequencing[T]): Fact

  39. def contain(only: ResultOfOnlyApplication)(implicit aggregating: Aggregating[T]): Fact

  40. def contain(theSameElementsInOrderAs: ResultOfTheSameElementsInOrderAsApplication)(implicit sequencing: Sequencing[T]): Fact

  41. def contain(theSameElementsAs: ResultOfTheSameElementsAsApplication)(implicit aggregating: Aggregating[T]): Fact

  42. def contain(noElementsOf: ResultOfNoElementsOfApplication)(implicit containing: Containing[T]): Fact

  43. def contain(noneOf: ResultOfNoneOfApplication)(implicit containing: Containing[T]): Fact

  44. def contain(atLeastOneElementOf: ResultOfAtLeastOneElementOfApplication)(implicit aggregating: Aggregating[T]): Fact

  45. def contain(atLeastOneOf: ResultOfAtLeastOneOfApplication)(implicit aggregating: Aggregating[T]): Fact

  46. def contain(oneElementOf: ResultOfOneElementOfApplication)(implicit evidence: Containing[T]): Fact

  47. def contain(newOneOf: ResultOfOneOfApplication)(implicit containing: Containing[T]): Fact

  48. def contain(expectedElement: Any)(implicit containing: Containing[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    object will not contain ("one")
                      ^
    

  49. def contain(nullValue: Null)(implicit containing: Containing[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    object will not contain (null)
                      ^
    

  50. def endWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    Definition Classes
    AnyRef
  53. def equal(right: Null): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not equal null
                      ^
    

  54. def equal(spread: Spread[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    sevenDotOh will not equal (6.5 +- 0.2)
                          ^
    

  55. def equal(right: Any)(implicit equality: Equality[T]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    result will not equal (7)
                      ^
    

  56. def equals(arg0: Any): Boolean

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

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  58. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication)(implicit ev: <:<[T, String]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

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

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

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

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

    Definition Classes
    AnyRef → Any
  61. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication)(implicit messaging: Messaging[T]): Fact

  62. def have(firstPropertyMatcher: HavePropertyMatcher[T, _], propertyMatchers: HavePropertyMatcher[T, _]*): Fact

    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 will not have (title ("One Hundred Years of Solitude"))
                    ^
    

  63. def have(resultOfSizeWordApplication: ResultOfSizeWordApplication)(implicit sz: Size[T]): Fact

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

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

  64. def have(resultOfLengthWordApplication: ResultOfLengthWordApplication)(implicit len: Length[T]): Fact

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

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

  65. def include(expectedSubstring: String)(implicit ev: <:<[T, String]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

    string will not include ("world")
                      ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

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

  67. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  68. val left: T

  69. def matchPattern(right: PartialFunction[Any, _]): Any

    This method enables the following syntax:

    This method enables the following syntax:

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

    Annotations
    @macroImpl( ... )
  70. final def ne(arg0: AnyRef): Boolean

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

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

    Definition Classes
    AnyRef
  73. val pos: Position

  74. val prettifier: Prettifier

  75. def startWith(expectedSubstring: String)(implicit ev: <:<[T, String]): Fact

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

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

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

    Definition Classes
    AnyRef
  78. def toString(): String

    Overrides toString to return pretty text.

    Overrides toString to return pretty text.

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

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  82. val willBeTrue: Boolean

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 will equal, will ===, willEqual, will be, or willBe instead.

    The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. Please use will equal, will ===, willEqual, will be, or willBe 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 will equal, will ===, willEqual, will be, or willBe instead.

Inherited from AnyRef

Inherited from Any

Ungrouped