org.scalatest.matchers.Matchers

class MatcherWrapper

[source: org/scalatest/matchers/Matchers.scala]

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 (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 [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 (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 (beWord : BeWord) : AndBeWord
This method enables the following syntax:
     isFileMock should (be a ('file) and be a ('file))
                                     ^
     
def and (endWithWord : EndWithWord) : AndEndWithWord
This method enables the following syntax:
     "1.7" should (endWith regex (decimalRegex) and endWith regex (decimalRegex))
                                                ^
     
def and (fullyMatchWord : FullyMatchWord) : AndFullyMatchWord
This method enables the following syntax:
     "1.7" should (fullyMatch regex (decimalRegex) and fullyMatch regex (decimalRegex))
                                                   ^
     
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 (haveWord : HaveWord) : AndHaveWord
This method enables the following syntax:
     Array(1, 2) should (have size (2) and have size (3 - 1))
                                       ^ 
     
def or (startWithWord : StartWithWord) : OrStartWithWord
This method enables the following syntax:
     "1.7" should (startWith regex ("hello") or startWith regex ("1.7"))
                                                ^
     
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 (containWord : ContainWord) : OrContainWord
This method enables the following syntax:
     Map("one" -> 1, "two" -> 2) should (contain value (7) or contain value (1))
                                                           ^
     
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 (fullyMatchWord : FullyMatchWord) : OrFullyMatchWord
This method enables the following syntax:
     "1.7" should (fullyMatch regex ("hello") or fullyMatch regex (decimal))
                                              ^
     
def or (endWithWord : EndWithWord) : OrEndWithWord
This method enables the following syntax:
     "1.7b" should (endWith regex ("hello") or endWith regex ("7b"))
                                               ^
     
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 [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))
                                     ^
     
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.