ScalaTest 1.0
org.scalatest.matchers.Matchers

class MatcherWrapper
[source: org/scalatest/matchers/Matchers.scala]
final class MatcherWrapper[T](leftMatcher : Matcher[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.
Author
Bill Venners
Method Summary
def and (startWithWord : StartWithWord) : AndStartWithWord
This method enables the following syntax: 
     "1.78" should (have length (4) and startWith regex ("1.7"))
                                    ^
def and (endWithWord : EndWithWord) : AndEndWithWord
This method enables the following syntax: 
     "1.7" should (endWith regex (decimalRegex) and endWith regex (decimalRegex))
                                                ^
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.
def and (notWord : NotWord) : AndNotWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (not contain value (5) and not contain value (3))
                                                               ^
def and (haveWord : HaveWord) : AndHaveWord
This method enables the following syntax: 
     Array(1, 2) should (have size (2) and have size (3 - 1))
                                       ^
def and (beWord : BeWord) : AndBeWord
This method enables the following syntax: 
     isFileMock should (be a ('file) and be a ('file))
                                     ^
def and (containWord : ContainWord) : AndContainWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (contain key ("two") and contain key ("one"))
                                                             ^
def and (includeWord : IncludeWord) : AndIncludeWord
This method enables the following syntax: 
     "hello, world" should (include regex ("hel*o") and include regex ("wor.d"))
                                               ^
def and (fullyMatchWord : FullyMatchWord) : AndFullyMatchWord
This method enables the following syntax: 
     "1.7" should (fullyMatch regex (decimalRegex) and fullyMatch regex (decimalRegex))
                                                   ^
def or (endWithWord : EndWithWord) : OrEndWithWord
This method enables the following syntax: 
     "1.7b" should (endWith regex ("hello") or endWith regex ("7b"))
                                               ^
def or (fullyMatchWord : FullyMatchWord) : OrFullyMatchWord
This method enables the following syntax: 
     "1.7" should (fullyMatch regex ("hello") or fullyMatch regex (decimal))
                                              ^
def or (startWithWord : StartWithWord) : OrStartWithWord
This method enables the following syntax: 
     "1.7" should (startWith regex ("hello") or startWith regex ("1.7"))
                                                ^
def or (containWord : ContainWord) : OrContainWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (contain value (7) or contain value (1))
                                                           ^
def or (notWord : NotWord) : OrNotWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (not contain value (2) or not contain value (3))
                                                               ^
def or (includeWord : IncludeWord) : OrIncludeWord
This method enables the following syntax: 
     "a1.7b" should (include regex ("1.7") or include regex ("1.7"))
                                              ^
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.
def or (beWord : BeWord) : OrBeWord
This method enables the following syntax: 
     isFileMock should (be a ('file) or be a ('directory))
                                     ^
def or (haveWord : HaveWord) : OrHaveWord
This method enables the following syntax: 
     Array(1, 2) should (have size (2) and have size (3 - 1))
                                       ^
Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized
Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf
Class Summary
final class AndBeWord 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.
final class AndContainWord 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.
final class AndEndWithWord 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.
final class AndFullyMatchWord 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.
final class AndHaveWord 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.
final class AndIncludeWord 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.
final class AndNotWord 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.
final class AndStartWithWord 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.
final class OrBeWord 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.
final class OrContainWord 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.
final class OrEndWithWord 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.
final class OrFullyMatchWord 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.
final class OrHaveWord 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.
final class OrIncludeWord 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.
final class OrNotWord 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.
final class OrStartWithWord 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.
Method Details
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.

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

Parameters
the - matcher to logical-and with this matcher
Returns
a matcher that performs the logical-and of this and the passed matcher
def and(haveWord : HaveWord) : AndHaveWord
This method enables the following syntax: 
     Array(1, 2) should (have size (2) and have size (3 - 1))
                                       ^
def and(containWord : ContainWord) : AndContainWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (contain key ("two") and contain key ("one"))
                                                             ^
def and(beWord : BeWord) : AndBeWord
This method enables the following syntax: 
     isFileMock should (be a ('file) and be a ('file))
                                     ^
def and(fullyMatchWord : FullyMatchWord) : AndFullyMatchWord
This method enables the following syntax: 
     "1.7" should (fullyMatch regex (decimalRegex) and fullyMatch regex (decimalRegex))
                                                   ^
def and(includeWord : IncludeWord) : AndIncludeWord
This method enables the following syntax: 
     "hello, world" should (include regex ("hel*o") and include regex ("wor.d"))
                                               ^
def and(startWithWord : StartWithWord) : AndStartWithWord
This method enables the following syntax: 
     "1.78" should (have length (4) and startWith regex ("1.7"))
                                    ^
def and(endWithWord : EndWithWord) : AndEndWithWord
This method enables the following syntax: 
     "1.7" should (endWith regex (decimalRegex) and endWith regex (decimalRegex))
                                                ^
def and(notWord : NotWord) : AndNotWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (not contain value (5) and not contain value (3))
                                                               ^
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.

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

Parameters
the - matcher to logical-or with this matcher
Returns
a matcher that performs the logical-or of this and the passed matcher
def or(haveWord : HaveWord) : OrHaveWord
This method enables the following syntax: 
     Array(1, 2) should (have size (2) and have size (3 - 1))
                                       ^
def or(containWord : ContainWord) : OrContainWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (contain value (7) or contain value (1))
                                                           ^
def or(beWord : BeWord) : OrBeWord
This method enables the following syntax: 
     isFileMock should (be a ('file) or be a ('directory))
                                     ^
def or(fullyMatchWord : FullyMatchWord) : OrFullyMatchWord
This method enables the following syntax: 
     "1.7" should (fullyMatch regex ("hello") or fullyMatch regex (decimal))
                                              ^
def or(includeWord : IncludeWord) : OrIncludeWord
This method enables the following syntax: 
     "a1.7b" should (include regex ("1.7") or include regex ("1.7"))
                                              ^
def or(startWithWord : StartWithWord) : OrStartWithWord
This method enables the following syntax: 
     "1.7" should (startWith regex ("hello") or startWith regex ("1.7"))
                                                ^
def or(endWithWord : EndWithWord) : OrEndWithWord
This method enables the following syntax: 
     "1.7b" should (endWith regex ("hello") or endWith regex ("7b"))
                                               ^
def or(notWord : NotWord) : OrNotWord
This method enables the following syntax: 
     Map("one" -> 1, "two" -> 2) should (not contain value (2) or not contain value (3))
                                                               ^
Copyright (C) 2001-2009 Artima, Inc. All rights reserved.
ScalaTest 1.0