AndNotWord

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(definedWord: DefinedWord): MatcherFactory1[T, Definition]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcher and not be defined
                    ^
   

8. def be(emptyWord: EmptyWord): MatcherFactory1[T, Emptiness]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcher and not be empty
                    ^
   

9. def be(writableWord: WritableWord): MatcherFactory1[T, Writability]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcher and not be writable
                    ^
   

10. def be(readableWord: ReadableWord): MatcherFactory1[T, Readability]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be readable
                     ^
    

11. def be(sortedWord: SortedWord): MatcherFactory1[T, Sortable]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be sorted
                     ^
    

12. def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[T with U]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be definedAt (8)
                     ^
    

13. def be[U](spread: Spread[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:

    aMatcher and not be (17.0 +- 0.2)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be theSameInstanceAs (otherString)
                     ^
    

15. def be(anType: ResultOfAnTypeInvocation[_]): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be an [Apple]
                     ^
    

    Annotations

    @macroImpl()

16. def be(aType: ResultOfATypeInvocation[_]): Matcher[T]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be a [Book]
                     ^
    

    Annotations

    @macroImpl()

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

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

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

    aMatcher and not be an (invalidMarks)
                     ^
    

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

    This method enables the following syntax, where directory is a BePropertyMatcher:

    This method enables the following syntax, where directory is a BePropertyMatcher:

    aMatcher and not be an (directory)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be an ('apple)
                     ^
    

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

    This method enables the following syntax, where directory is a BePropertyMatcher:

    This method enables the following syntax, where directory is a BePropertyMatcher:

    aMatcher and not be a (directory)
                     ^
    

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

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

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

    aMatcher and not be a (validMarks)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be a ('file)
                     ^
    

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

    This method enables the following syntax, where directory is a BePropertyMatcher:

    This method enables the following syntax, where directory is a BePropertyMatcher:

    aMatcher and not be (directory)
                     ^
    

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

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

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

    aMatcher and not be (odd)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be ('empty)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be === (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be >= (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be <= (2)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be > (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be (null)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be < (6)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not be (3 - 1)
                     ^
    

33. def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws()

34. def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[T, ValueMapping]

    This method enables the following syntax given a Matcher:

    This method enables the following syntax given a Matcher:

    aMatcher and not contain value (3)
                     ^
    

35. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping]

    This method enables the following syntax given a Matcher:

    This method enables the following syntax given a Matcher:

    aMatcher and not contain key ("three")
                     ^
    

36. def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory1[T, Aggregating]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain atMostOneOf (8, 1, 2)
                             ^
    

37. def contain(right: ResultOfInOrderApplication): MatcherFactory1[T, Sequencing]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain inOrder (8, 1, 2)
                     ^
    

38. def contain(right: ResultOfAllOfApplication): MatcherFactory1[T, Aggregating]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain allOf (8, 1, 2)
                     ^
    

39. def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory1[T, Sequencing]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain inOrderOnly (8, 1, 2)
                     ^
    

40. def contain(right: ResultOfOnlyApplication): MatcherFactory1[T, Aggregating]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain only (List(8, 1, 2))
                     ^
    

41. def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[T, Sequencing]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain theSameElementsInOrderAs (List(8, 1, 2))
                     ^
    

42. def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory1[T, Aggregating]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain theSameElementsAs (List(8, 1, 2))
                     ^
    

43. def contain(right: ResultOfNoneOfApplication): MatcherFactory1[T, Containing]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain noneOf (List(8, 1, 2))
                     ^
    

44. def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory1[T, Aggregating]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain atLeastOneOf (List(8, 1, 2))
                     ^
    

45. def contain(right: ResultOfOneOfApplication): MatcherFactory1[T, Containing]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain oneOf (List(8, 1, 2))
                     ^
    

46. def contain[U](expectedElement: U): MatcherFactory1[T, Containing]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not contain (3)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not endWith ("1.7")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not endWith regex (decimal)
                     ^
    

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

    Definition Classes

    AnyRef

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not equal (null)
                     ^
    

51. def equal[U](spread: Spread[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:

    aMatcher and not equal (17.0 +- 0.2)
                     ^
    

52. def equal(any: Any): MatcherFactory1[T, Equality]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not equal (3 - 1)
                     ^
    

53. def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

54. def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws()

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not fullyMatch regex (decimal)
                     ^
    

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

    Definition Classes

    AnyRef → Any

57. def hashCode(): Int

    Definition Classes

    AnyRef → Any

58. 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:

    aMatcher and not have (author ("Melville"))
                     ^
    

59. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[T, Messaging]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have message ("Message from Mars!")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have size (3)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not have length (3)
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not include ("1.7")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not include regex (decimal)
                     ^
    

64. final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not matchPattern { case Person("Bob", _) =>}
                     ^
    

    Annotations

    @macroImpl()

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

    Definition Classes

    AnyRef

67. final def notify(): Unit

    Definition Classes

    AnyRef

68. final def notifyAll(): Unit

    Definition Classes

    AnyRef

69. val owner: Matcher[T]

    Get the Matcher instance, currently used by macro only.

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not startWith ("1.7")
                     ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcher and not startWith regex (decimal)
                     ^
    

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

    Definition Classes

    AnyRef

73. def toString(): String

    Definition Classes

    AnyRef → Any

74. final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws()

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

    Definition Classes

    AnyRef

    Annotations

    @throws()

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

    Definition Classes

    AnyRef

    Annotations

    @throws()