org.scalatest.matchers.ClassicMatchers

MatcherWrapper

class MatcherWrapper [T] extends AnyRef

This class is part of the ScalaTest matchers DSL. Please see the documentation for ShouldMatchers or MustMatchers for an overview of the matchers DSL.

Attributes
final
Self Type
MatcherWrapper[T]
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. MatcherWrapper
  2. AnyRef
  3. Any
Visibility
  1. Public
  2. All

Instance Constructors

  1. new MatcherWrapper (leftMatcher: Matcher[T])

Type Members

  1. class AndBeWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  2. class AndContainWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  3. class AndEndWithWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  4. class AndFullyMatchWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  5. class AndHaveWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  6. class AndIncludeWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  7. class AndNotWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  8. class AndStartWithWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  9. class OrBeWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  10. class OrContainWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  11. class OrEndWithWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  12. class OrFullyMatchWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  13. class OrHaveWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  14. class OrIncludeWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  15. class OrNotWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  16. class OrStartWithWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

Value Members

  1. def != (arg0: AnyRef): Boolean

    Attributes
    final
    Definition Classes
    AnyRef
  2. def != (arg0: Any): Boolean

    Attributes
    final
    Definition Classes
    Any
  3. def ## (): Int

    Attributes
    final
    Definition Classes
    AnyRef → Any
  4. def == (arg0: AnyRef): Boolean

    Attributes
    final
    Definition Classes
    AnyRef
  5. def == (arg0: Any): Boolean

    Attributes
    final
    Definition Classes
    Any
  6. def and (notWord: NotWord): AndNotWord

    This method enables the following syntax:

    This method enables the following syntax:

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

  7. def and (endWithWord: EndWithWord): AndEndWithWord

    This method enables the following syntax:

    This method enables the following syntax:

    "1.7" should (endWith regex (decimalRegex) and endWith regex (decimalRegex))
                                               ^
    

  8. def and (startWithWord: StartWithWord): AndStartWithWord

    This method enables the following syntax:

    This method enables the following syntax:

    "1.78" should (have length (4) and startWith regex ("1.7"))
                                   ^
    

  9. def and (includeWord: IncludeWord): AndIncludeWord

    This method enables the following syntax:

    This method enables the following syntax:

    "hello, world" should (include regex ("hel*o") and include regex ("wor.d"))
                                              ^
    

  10. def and (fullyMatchWord: FullyMatchWord): AndFullyMatchWord

    This method enables the following syntax:

    This method enables the following syntax:

    "1.7" should (fullyMatch regex (decimalRegex) and fullyMatch regex (decimalRegex))
                                                  ^
    

  11. def and (beWord: BeWord): AndBeWord

    This method enables the following syntax:

    This method enables the following syntax:

    isFileMock should (be a ('file) and be a ('file))
                                    ^
    

  12. def and (containWord: ContainWord): AndContainWord

    This method enables the following syntax:

    This method enables the following syntax:

    Map("one" -> 1, "two" -> 2) should (contain key ("two") and contain key ("one"))
                                                            ^
    

  13. def and (haveWord: HaveWord): AndHaveWord

    This method enables the following syntax:

    This method enables the following syntax:

    Array(1, 2) should (have size (2) and have size (3 - 1))
                                      ^
    

  14. def and [U <: T] (rightMatcher: Matcher[U]): Matcher[U]

    Returns a matcher whose apply method returns a MatchResult that represents the logical-and of the results of the wrapped and the passed matcher applied to the same value.

    Returns a matcher whose apply method returns a MatchResult that represents the logical-and of the results of the wrapped and the passed matcher applied to the same value.

    The reason and has an upper bound on its type parameter is so that the Matcher resulting from an invocation of and will have the correct type parameter. If you call and on a Matcher[Orange], passing in a Matcher[Valencia], the result will have type Matcher[Valencia]. This is correct because both a Matcher[Orange] and a Matcher[Valencia] know how to match a Valencia (but a Matcher[Valencia] doesn't know how to match any old Orange). If you call and on a Matcher[Orange], passing in a Matcher[Fruit], the result will have type Matcher[Orange]. This is also correct because both a Matcher[Orange] and a Matcher[Fruit] know how to match an Orange (but a Matcher[Orange] doesn't know how to match any old Fruit).

    returns

    a matcher that performs the logical-and of this and the passed matcher

  15. def asInstanceOf [T0] : T0

    Attributes
    final
    Definition Classes
    Any
  16. def clone (): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  17. def eq (arg0: AnyRef): Boolean

    Attributes
    final
    Definition Classes
    AnyRef
  18. def equals (arg0: Any): Boolean

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

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  20. def getClass (): java.lang.Class[_]

    Attributes
    final
    Definition Classes
    AnyRef
  21. def hashCode (): Int

    Definition Classes
    AnyRef → Any
  22. def isInstanceOf [T0] : Boolean

    Attributes
    final
    Definition Classes
    Any
  23. def ne (arg0: AnyRef): Boolean

    Attributes
    final
    Definition Classes
    AnyRef
  24. def notify (): Unit

    Attributes
    final
    Definition Classes
    AnyRef
  25. def notifyAll (): Unit

    Attributes
    final
    Definition Classes
    AnyRef
  26. def or (notWord: NotWord): OrNotWord

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

  27. def or (endWithWord: EndWithWord): OrEndWithWord

    This method enables the following syntax:

    This method enables the following syntax:

    "1.7b" should (endWith regex ("hello") or endWith regex ("7b"))
                                              ^
    

  28. def or (startWithWord: StartWithWord): OrStartWithWord

    This method enables the following syntax:

    This method enables the following syntax:

    "1.7" should (startWith regex ("hello") or startWith regex ("1.7"))
                                               ^
    

  29. def or (includeWord: IncludeWord): OrIncludeWord

    This method enables the following syntax:

    This method enables the following syntax:

    "a1.7b" should (include regex ("1.7") or include regex ("1.7"))
                                             ^
    

  30. def or (fullyMatchWord: FullyMatchWord): OrFullyMatchWord

    This method enables the following syntax:

    This method enables the following syntax:

    "1.7" should (fullyMatch regex ("hello") or fullyMatch regex (decimal))
                                             ^
    

  31. def or (beWord: BeWord): OrBeWord

    This method enables the following syntax:

    This method enables the following syntax:

    isFileMock should (be a ('file) or be a ('directory))
                                    ^
    

  32. def or (containWord: ContainWord): OrContainWord

    This method enables the following syntax:

    This method enables the following syntax:

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

  33. def or (haveWord: HaveWord): OrHaveWord

    This method enables the following syntax:

    This method enables the following syntax:

    Array(1, 2) should (have size (2) and have size (3 - 1))
                                      ^
    

  34. def or [U <: T] (rightMatcher: Matcher[U]): Matcher[U]

    Returns a matcher whose apply method returns a MatchResult that represents the logical-or of the results of this and the passed matcher applied to the same value.

    Returns a matcher whose apply method returns a MatchResult that represents the logical-or of the results of this and the passed matcher applied to the same value.

    The reason or has an upper bound on its type parameter is so that the Matcher resulting from an invocation of or will have the correct type parameter. If you call or on a Matcher[Orange], passing in a Matcher[Valencia], the result will have type Matcher[Valencia]. This is correct because both a Matcher[Orange] and a Matcher[Valencia] know how to match a Valencia (but a Matcher[Valencia] doesn't know how to match any old Orange). If you call or on a Matcher[Orange], passing in a Matcher[Fruit], the result will have type Matcher[Orange]. This is also correct because both a Matcher[Orange] and a Matcher[Fruit] know how to match an Orange (but a Matcher[Orange] doesn't know how to match any old Fruit).

    returns

    a matcher that performs the logical-or of this and the passed matcher

  35. def synchronized [T0] (arg0: ⇒ T0): T0

    Attributes
    final
    Definition Classes
    AnyRef
  36. def toString (): String

    Definition Classes
    AnyRef → Any
  37. def wait (): Unit

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

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

    Attributes
    final
    Definition Classes
    AnyRef
    Annotations
    @throws()

Inherited from AnyRef

Inherited from Any