MatcherWrapper

Instance Constructors

new MatcherWrapper(leftMatcher: Matcher[T])

Type Members

final class AndBeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndContainWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndEndWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndFullyMatchWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndHaveWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndIncludeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndNotWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AndStartWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrBeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrContainWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrEndWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrFullyMatchWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrHaveWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrIncludeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrNotWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class OrStartWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any

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(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))
                                           ^
```
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"))
                               ^
```
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"))
                                          ^
```
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))
                                              ^
```
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))
                                ^
```

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:
This method enables the following syntax:
```
Array(1, 2) should (have size (2) and have size (3 - 1))
                                  ^
```
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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

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

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

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

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef

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(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"))
                                          ^
```
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"))
                                           ^
```
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"))
                                         ^
```
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))
                                         ^
```
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))
                                ^
```

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(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))
                                  ^
```
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
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws()

final class MatcherWrapper[T] extends AnyRef

Instance Constructors

new MatcherWrapper(leftMatcher: Matcher[T])

Type Members

final class AndBeWord extends AnyRef

final class AndContainWord extends AnyRef

final class AndEndWithWord extends AnyRef

final class AndFullyMatchWord extends AnyRef

final class AndHaveWord extends AnyRef

final class AndIncludeWord extends AnyRef

final class AndNotWord extends AnyRef

final class AndStartWithWord extends AnyRef

final class OrBeWord extends AnyRef

final class OrContainWord extends AnyRef

final class OrEndWithWord extends AnyRef

final class OrFullyMatchWord extends AnyRef

final class OrHaveWord extends AnyRef

final class OrIncludeWord extends AnyRef

final class OrNotWord extends AnyRef

final class OrStartWithWord extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def and(notWord: NotWord): AndNotWord

def and(endWithWord: EndWithWord): AndEndWithWord

def and(startWithWord: StartWithWord): AndStartWithWord

def and(includeWord: IncludeWord): AndIncludeWord

def and(fullyMatchWord: FullyMatchWord): AndFullyMatchWord

def and(beWord: BeWord): AndBeWord

def and(containWord: ContainWord): AndContainWord

def and(haveWord: HaveWord): AndHaveWord

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def or(notWord: NotWord): OrNotWord

def or(endWithWord: EndWithWord): OrEndWithWord

def or(startWithWord: StartWithWord): OrStartWithWord

def or(includeWord: IncludeWord): OrIncludeWord

def or(fullyMatchWord: FullyMatchWord): OrFullyMatchWord

def or(beWord: BeWord): OrBeWord

def or(containWord: ContainWord): OrContainWord

def or(haveWord: HaveWord): OrHaveWord

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

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped