OrNotWord

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](interval: Interval[U]): Matcher[T with U]

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

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

   sevenDotOh should (not be (17.0 +- 0.2) or not be (17.0 +- 0.2))
                                                  ^
   

8. def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T]

   This method enables the following syntax:

   This method enables the following syntax:

   obj should (not be theSameInstanceAs (otherString) or not be theSameInstanceAs (string))
                                                             ^
   

9. def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with U]

   This method enables the following syntax:

   This method enables the following syntax:

   result should (not be an (oddMarks) and not be an (invalidMarks))
                                                  ^
   

10. def be[U <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    myFile should (not be an (directory) or not be an (file))
                                                ^
    

11. def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    notAppleMock should (not be an ('apple) or not be an ('apple))
                                                   ^
    

12. def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    myFile should (not be a (directory) or not be a (file))
                                               ^
    

13. def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    result should (not be a (passedMarks) or not be a (validMarks))
                                                    ^
    

14. def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    isNotFileMock should (not be a ('directory) or not be a ('file))
                                                       ^
    

15. def be[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    myFile should (not be (directory) or not be (file))
                                             ^
    

16. def be[U](beMatcher: BeMatcher[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    2 should (not be (even) or not be (odd))
                                   ^
    

17. def be(symbol: Symbol): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    notEmptyMock should (not be ('full) or not be ('empty))
                                               ^
    

18. def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    5 should (not be === (7) or not be === (8))
                                    ^
    

19. def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    8 should (not be >= (7) or not be >= (6))
                                   ^
    

20. def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    2 should (not be <= (3) or not be <= (2))
                                   ^
    

21. def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    7 should (not be > (5) or not be > (6))
                                  ^
    

22. def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    5 should (not be < (7) or not be < (8))
                                  ^
    

23. def be(o: Null): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    map should (contain key (7) or not be (null))
                                       ^
    

24. def be(any: Any): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    1 should (not be (1) or not be (2))
                                ^
    

25. def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws()

26. def contain[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with GenTraversable[U]]

    This method enables the following syntax:

    This method enables the following syntax:

    result should (not contain an oddNumber or not contain an invalidNumber)
                                                   ^
    

27. def contain[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with GenTraversable[U]]

    This method enables the following syntax:

    This method enables the following syntax:

    result should (not contain a negativeNumber or not contain a primeNumber)
                                                       ^
    

28. def contain[U](right: ContainMatcher[U]): Matcher[T with GenTraversable[U]]

    This method enables the following syntax:

    This method enables the following syntax:

    collection should (contain theSameElementsAs (List(1, 2, 3)) or not contain theSameElementsAs (List(8, 1, 2)))
                                                                        ^
    

29. def contain[U](resultOfValueWordApplication: ResultOfValueWordApplication[U]): Matcher[T with GenMap[K, U] forSome {type K}]

    This method enables the following syntax:

    This method enables the following syntax:

    Map("one" -> 1, "two" -> 2) should (not contain value (2) or not contain value (3))
                                                                     ^
    

30. def contain[U](resultOfKeyWordApplication: ResultOfKeyWordApplication[U]): Matcher[T with GenMap[U, Any]]

    This method enables the following syntax:

    This method enables the following syntax:

    Map("one" -> 1, "two" -> 2) should (not contain key ("two") or not contain key ("three"))
                                                                       ^
    

31. def contain[U](expectedElement: U): MatcherFactory1[T, Holder]

    This method enables the following syntax:

    This method enables the following syntax:

    Array(1, 2) should (not contain (1) or not contain (3))
                                               ^
    

32. def endWith(expectedSubstring: String): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not endWith ("fred") or not endWith ("1.7"))
                                               ^
    

33. def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not endWith regex ("bob") or not endWith regex (decimal))
                                                    ^
    

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

    Definition Classes

    AnyRef

35. def equal(o: Null): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    aNullRef should (not equal (null) or not equal (null))
                                             ^
    

36. def equal[U](interval: Interval[U]): Matcher[T with U]

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

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

    sevenDotOh should (not equal (17.0 +- 0.2) or not equal (17.0 +- 0.2))
                                                      ^
    

37. def equal(any: Any): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    1 should (not equal (1) or not equal (2))
                                   ^
    

38. def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

39. def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws()

40. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not fullyMatch regex ("fred") or not fullyMatch regex (decimal))
                                                        ^
    

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

    Definition Classes

    AnyRef → Any

42. def hashCode(): Int

    Definition Classes

    AnyRef → Any

43. def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    book should (not have (title ("Moby Dick")) or not have (author ("Melville")))
                                                       ^
    

44. def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[T, Size]

    This method enables the following syntax:

    This method enables the following syntax:

    Array(1, 2) should (not have size (2) or not have size (3))
                                                 ^
    

45. def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[T, Length]

    This method enables the following syntax:

    This method enables the following syntax:

    Array(1, 2) should (not have length (2) or not have length (3))
                                                   ^
    

46. def include(expectedSubstring: String): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not include ("bob") or not include ("1.7"))
                                              ^
    

47. def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not include regex ("fred") or not include regex (decimal))
                                                     ^
    

48. final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

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

    Definition Classes

    AnyRef

50. final def notify(): Unit

    Definition Classes

    AnyRef

51. final def notifyAll(): Unit

    Definition Classes

    AnyRef

52. def startWith(expectedSubstring: String): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not startWith ("fred") or not startWith ("1.7"))
                                                 ^
    

53. def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]

    This method enables the following syntax:

    This method enables the following syntax:

    "fred" should (not startWith regex ("bob") or not startWith regex (decimal))
                                                      ^
    

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

    Definition Classes

    AnyRef

55. def toString(): String

    Definition Classes

    AnyRef → Any

56. final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws()

57. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws()

58. final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws()