org.scalatest.matchers.Matchers

# 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