org.scalatest.matchers.ClassicMatchers.MatcherWrapper

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

MatcherWrapper
AnyRef
Any

Visibility

Public
All

Instance Constructors

new MatcherWrapper (leftMatcher: Matcher[T])

Type Members

class AndBeWord extends AnyRef

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This class is part of the ScalaTest matchers DSL.

Value Members

def != (arg0: AnyRef): Boolean

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

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

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

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

Attributes
final
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
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
def clone (): AnyRef

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

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

Definition Classes
AnyRef → Any
def finalize (): Unit

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

Attributes
final
Definition Classes
AnyRef
def hashCode (): Int

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

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

Attributes
final
Definition Classes
AnyRef
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

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

Attributes
final
Definition Classes
AnyRef
def toString (): String

Definition Classes
AnyRef → Any
def wait (): Unit

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

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

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()

MatcherWrapper

class MatcherWrapper [T] extends AnyRef

Instance Constructors

new MatcherWrapper (leftMatcher: Matcher[T])

Type Members

class AndBeWord extends AnyRef

class AndContainWord extends AnyRef

class AndEndWithWord extends AnyRef

class AndFullyMatchWord extends AnyRef

class AndHaveWord extends AnyRef

class AndIncludeWord extends AnyRef

class AndNotWord extends AnyRef

class AndStartWithWord extends AnyRef

class OrBeWord extends AnyRef

class OrContainWord extends AnyRef

class OrEndWithWord extends AnyRef

class OrFullyMatchWord extends AnyRef

class OrHaveWord extends AnyRef

class OrIncludeWord extends AnyRef

class OrNotWord extends AnyRef

class OrStartWithWord extends AnyRef

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

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]

def asInstanceOf [T0] : T0

def clone (): AnyRef

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def notify (): Unit

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]

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

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

Inherited from AnyRef

Inherited from Any