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(definedWord: DefinedWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Definition]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcherFactory and not be defined
                           ^
   

6.  def be(emptyWord: EmptyWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Emptiness]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcherFactory and not be empty
                           ^
   

7.  def be(writableWord: WritableWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Writability]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcherFactory and not be writable
                           ^
   

8.  def be(readableWord: ReadableWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Readability]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcherFactory and not be readable
                           ^
   

9.  def be(sortedWord: SortedWord): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sortable]

   This method enables the following syntax:

   This method enables the following syntax:

   aMatcherFactory and not be sorted
                           ^
   

10.  def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax, where fraction is a PartialFunction:

    This method enables the following syntax, where fraction is a PartialFunction:

    aMatcherFactory and not be definedAt (8)
                            ^
    

11.  def be[U](spread: Spread[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be (17.0 +- 0.2)
                            ^
    

12.  def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be theSameInstanceAs (otherString)
                            ^
    

13.  macro def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be an [Apple]
                            ^
    

14.  macro def be(aType: ResultOfATypeInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be a [Book]
                            ^
    

15.  def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4, where invalidMarks is a AnMatcher:

    This method enables the following syntax given a MatcherFactory4, where invalidMarks is a AnMatcher:

    aMatcherFactory and not be an (invalidMarks)
                            ^
    

16.  def be[SC <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[SC]): MatcherFactory4[SC with SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4, where apple is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory4, where apple is a BePropertyMatcher:

    aMatcherFactory and not be an (apple)
                            ^
    

17.  def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be a (directory)
                            ^
    

18.  def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be a (validMarks)
                            ^
    

19.  def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be (directory)
                            ^
    

20.  def be[U](beMatcher: BeMatcher[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not be (odd)
                            ^
    

21.  def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

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

    The deprecation period for the should be === syntax has expired, and the syntax may no longer be used. 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.

22.  def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be >= (6)
                            ^
    

23.  def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be <= (2)
                            ^
    

24.  def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory (8) and not be > (6)
                                ^
    

25.  def be(o: Null): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be (null)
                            ^
    

26.  def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be < (6)
                            ^
    

27.  def be(any: Any): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not be (3 - 1)
                            ^
    

28.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

29.  def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain atMostOneElementOf (List(8, 1, 2))
                            ^
    

30.  def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

31.  def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

32.  def contain(right: ResultOfInOrderApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

33.  def contain(right: ResultOfAllElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain allElementsOf (8, 1, 2)
                            ^
    

34.  def contain(right: ResultOfAllOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

35.  def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

36.  def contain(right: ResultOfOnlyApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain only (8, 1, 2)
                            ^
    

37.  def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Sequencing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

38.  def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

39.  def contain(right: ResultOfNoElementsOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain noElementsOf (8, 1, 2)
                            ^
    

40.  def contain(right: ResultOfNoneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain noneOf (8, 1, 2)
                            ^
    

41.  def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                            ^
    

42.  def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Aggregating]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain atLeastOneOf (8, 1, 2)
                            ^
    

43.  def contain(right: ResultOfOneElementOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain oneElementOf (List(8, 1, 2))
                            ^
    

44.  def contain(right: ResultOfOneOfApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain oneOf (8, 1, 2)
                            ^
    

45.  def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, ValueMapping]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain value (3)
                            ^
    

46.  def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, KeyMapping]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain key ("three")
                            ^
    

47.  def contain[U](expectedElement: U): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Containing]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not contain (3)
                            ^
    

48.  def endWith(expectedSubstring: String): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not endWith ("1.7")
                            ^
    

49.  def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not endWith regex (decimal)
                            ^
    

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

    Definition Classes

    AnyRef

51.  def equal(o: Null): MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not equal (null)
                            ^
    

52.  def equal[U](spread: Spread[U]): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

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

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

    aMatcherFactory and not equal (17.0 +- 0.2)
                            ^
    

53.  def equal(any: Any): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Equality]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not equal (3 - 1)
                            ^
    

54.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

55.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

56.  def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not fullyMatch regex (decimal)
                            ^
    

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

    Definition Classes

    AnyRef → Any

58.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

59.  def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory4[SC with U, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

60.  def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Messaging]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

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

61.  def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Size]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not have size (3)
                            ^
    

62.  def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory5[SC, TC1, TC2, TC3, TC4, Length]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not have length (3)
                            ^
    

63.  def include(expectedSubstring: String): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not include ("1.7")
                            ^
    

64.  def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not include regex (decimal)
                            ^
    

65.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

66.  macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]

    This method enables the following syntax:

    This method enables the following syntax:

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

67.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

68.  final def notify(): Unit

    Definition Classes

    AnyRef

69.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

70.  val owner: MatcherFactory4[SC, TC1, TC2, TC3, TC4]

    Get the MatcherFactory instance, currently used by macro only.

    Get the MatcherFactory instance, currently used by macro only.

71.  def startWith(expectedSubstring: String): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not startWith ("1.7")
                            ^
    

72.  def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory4[SC with String, TC1, TC2, TC3, TC4]

    This method enables the following syntax given a MatcherFactory4:

    This method enables the following syntax given a MatcherFactory4:

    aMatcherFactory and not startWith regex (decimal)
                            ^
    

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

    Definition Classes

    AnyRef

74.  def toString(): String

    Definition Classes

    AnyRef → Any

75.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

77.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )