MatcherFactory1

Instance Constructors

new MatcherFactory1()

Type Members

final class AndBeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndContainWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndEndWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndFullyMatchWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndHaveWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndIncludeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndNotWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class AndStartWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrBeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrContainWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrEndWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrFullyMatchWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrHaveWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrIncludeWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrNotWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.
final class OrStartWithWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Abstract Value Members

abstract def matcher[T <: SC](implicit arg0: TC1[T]): Matcher[T]

Factory method that will produce a Matcher[T], where T is a subtype of (or the same type as) SC, given a typeclass instance for each TCn implicit parameter (for example, a TC1[T], TC2[T], etc.).
Factory method that will produce a Matcher[T], where T is a subtype of (or the same type as) SC, given a typeclass instance for each TCn implicit parameter (for example, a TC1[T], TC2[T], etc.).

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
def and(notExist: ResultOfNotExist): MatcherFactory2[SC, TC1, Existence]

This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and not (exist)
                ^
```
def and(existWord: ExistWord): MatcherFactory2[SC, TC1, Existence]

This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory and exist
                ^
```
def and(notWord: NotWord): AndNotWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and not contain value (3)
                ^
```
def and(endWithWord: EndWithWord): AndEndWithWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and endWith regex (decimalRegex)
                ^
```
def and(startWithWord: StartWithWord): AndStartWithWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and startWith regex ("1.7")
                ^
```
def and(includeWord: IncludeWord): AndIncludeWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and include regex ("wor.d")
                ^
```
def and(fullyMatchWord: FullyMatchWord): AndFullyMatchWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and fullyMatch regex (decimalRegex)
                ^
```
def and(beWord: BeWord): AndBeWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and be a ('file)
                ^
```
def and(containWord: ContainWord): AndContainWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and contain key ("one")
                ^
```
def and(haveWord: HaveWord): AndHaveWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory and have size (3 - 1)
                    ^
```
def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_], TC9[_]](rightMatcherFactory: MatcherFactory8[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]): MatcherFactory9[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_]](rightMatcherFactory: MatcherFactory7[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8]): MatcherFactory8[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_]](rightMatcherFactory: MatcherFactory6[U, TC2, TC3, TC4, TC5, TC6, TC7]): MatcherFactory7[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_]](rightMatcherFactory: MatcherFactory5[U, TC2, TC3, TC4, TC5, TC6]): MatcherFactory6[U, TC1, TC2, TC3, TC4, TC5, TC6]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_]](rightMatcherFactory: MatcherFactory4[U, TC2, TC3, TC4, TC5]): MatcherFactory5[U, TC1, TC2, TC3, TC4, TC5]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_], TC3[_], TC4[_]](rightMatcherFactory: MatcherFactory3[U, TC2, TC3, TC4]): MatcherFactory4[U, TC1, TC2, TC3, TC4]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_], TC3[_]](rightMatcherFactory: MatcherFactory2[U, TC2, TC3]): MatcherFactory3[U, TC1, TC2, TC3]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC, TC2[_]](rightMatcherFactory: MatcherFactory1[U, TC2]): MatcherFactory2[U, TC1, TC2]

Ands this matcher factory with the passed matcher factory.
def and[U <: SC](rightMatcherFactory: MatcherFactory1[U, TC1]): MatcherFactory1[U, TC1]

Ands this matcher factory with the passed MatcherFactory1 that has the same final typeclass as this one.
Ands this matcher factory with the passed MatcherFactory1 that has the same final typeclass as this one.
def and[U <: SC](rightMatcher: Matcher[U]): MatcherFactory1[U, TC1]

Ands this matcher factory with the passed matcher.
def apply[T <: SC](explicit: TC1[T]): Matcher[T]

Enables the Explicitly DSL to be used directly on a MatcherFactory1, without invoking the matcher factory method.
Enables the Explicitly DSL to be used directly on a MatcherFactory1, without invoking the matcher factory method.
Here's an example of the kind of syntax this apply method can enable:
```
result should equal (1) (decided by defaultEquality)
```
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( classOf[java.lang.Throwable] )
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(notExist: ResultOfNotExist): MatcherFactory2[SC, TC1, Existence]

This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory or not (exist)
                ^
```
def or(existWord: ExistWord): MatcherFactory2[SC, TC1, Existence]

This method enables the following syntax:
This method enables the following syntax:
```
aMatcherFactory or exist
                ^
```
def or(notWord: NotWord): OrNotWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or not contain value (3)
                ^
```
def or(endWithWord: EndWithWord): OrEndWithWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or endWith regex ("7b")
                ^
```
def or(startWithWord: StartWithWord): OrStartWithWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or startWith regex ("1.7")
                ^
```
def or(includeWord: IncludeWord): OrIncludeWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or include regex ("1.7")
                ^
```
def or(fullyMatchWord: FullyMatchWord): OrFullyMatchWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or fullyMatch regex (decimal)
                ^
```
def or(beWord: BeWord): OrBeWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or be a ('directory)
                ^
```
def or(containWord: ContainWord): OrContainWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
(aMatcherFactory or contain value (1))
                 ^
```
def or(haveWord: HaveWord): OrHaveWord

This method enables the following syntax given a MatcherFactory1:
This method enables the following syntax given a MatcherFactory1:
```
aMatcherFactory or have size (3 - 1)
                ^
```
def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_], TC9[_]](rightMatcherFactory: MatcherFactory8[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]): MatcherFactory9[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_]](rightMatcherFactory: MatcherFactory7[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8]): MatcherFactory8[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_]](rightMatcherFactory: MatcherFactory6[U, TC2, TC3, TC4, TC5, TC6, TC7]): MatcherFactory7[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_]](rightMatcherFactory: MatcherFactory5[U, TC2, TC3, TC4, TC5, TC6]): MatcherFactory6[U, TC1, TC2, TC3, TC4, TC5, TC6]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_]](rightMatcherFactory: MatcherFactory4[U, TC2, TC3, TC4, TC5]): MatcherFactory5[U, TC1, TC2, TC3, TC4, TC5]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_], TC3[_], TC4[_]](rightMatcherFactory: MatcherFactory3[U, TC2, TC3, TC4]): MatcherFactory4[U, TC1, TC2, TC3, TC4]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_], TC3[_]](rightMatcherFactory: MatcherFactory2[U, TC2, TC3]): MatcherFactory3[U, TC1, TC2, TC3]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC, TC2[_]](rightMatcherFactory: MatcherFactory1[U, TC2]): MatcherFactory2[U, TC1, TC2]

Ors this matcher factory with the passed matcher factory.
def or[U <: SC](rightMatcherFactory: MatcherFactory1[U, TC1]): MatcherFactory1[U, TC1]

Ors this matcher factory with the passed MatcherFactory1 that has the same final typeclass as this one.
Ors this matcher factory with the passed MatcherFactory1 that has the same final typeclass as this one.
def or[U <: SC](rightMatcher: Matcher[U]): MatcherFactory1[U, TC1]

Ors this matcher factory with 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( ... )

Related Docs: object MatcherFactory1 | package matchers

abstract class MatcherFactory1[-SC, TC1[_]] extends AnyRef

Instance Constructors

new MatcherFactory1()

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

Abstract Value Members

abstract def matcher[T <: SC](implicit arg0: TC1[T]): Matcher[T]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def and(notExist: ResultOfNotExist): MatcherFactory2[SC, TC1, Existence]

def and(existWord: ExistWord): MatcherFactory2[SC, TC1, Existence]

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 <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_], TC9[_]](rightMatcherFactory: MatcherFactory8[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]): MatcherFactory9[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]

def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_]](rightMatcherFactory: MatcherFactory7[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8]): MatcherFactory8[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8]

def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_]](rightMatcherFactory: MatcherFactory6[U, TC2, TC3, TC4, TC5, TC6, TC7]): MatcherFactory7[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_]](rightMatcherFactory: MatcherFactory5[U, TC2, TC3, TC4, TC5, TC6]): MatcherFactory6[U, TC1, TC2, TC3, TC4, TC5, TC6]

def and[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_]](rightMatcherFactory: MatcherFactory4[U, TC2, TC3, TC4, TC5]): MatcherFactory5[U, TC1, TC2, TC3, TC4, TC5]

def and[U <: SC, TC2[_], TC3[_], TC4[_]](rightMatcherFactory: MatcherFactory3[U, TC2, TC3, TC4]): MatcherFactory4[U, TC1, TC2, TC3, TC4]

def and[U <: SC, TC2[_], TC3[_]](rightMatcherFactory: MatcherFactory2[U, TC2, TC3]): MatcherFactory3[U, TC1, TC2, TC3]

def and[U <: SC, TC2[_]](rightMatcherFactory: MatcherFactory1[U, TC2]): MatcherFactory2[U, TC1, TC2]

def and[U <: SC](rightMatcherFactory: MatcherFactory1[U, TC1]): MatcherFactory1[U, TC1]

def and[U <: SC](rightMatcher: Matcher[U]): MatcherFactory1[U, TC1]

def apply[T <: SC](explicit: TC1[T]): Matcher[T]

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(notExist: ResultOfNotExist): MatcherFactory2[SC, TC1, Existence]

def or(existWord: ExistWord): MatcherFactory2[SC, TC1, Existence]

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 <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_], TC9[_]](rightMatcherFactory: MatcherFactory8[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]): MatcherFactory9[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8, TC9]

def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_], TC8[_]](rightMatcherFactory: MatcherFactory7[U, TC2, TC3, TC4, TC5, TC6, TC7, TC8]): MatcherFactory8[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8]

def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_], TC7[_]](rightMatcherFactory: MatcherFactory6[U, TC2, TC3, TC4, TC5, TC6, TC7]): MatcherFactory7[U, TC1, TC2, TC3, TC4, TC5, TC6, TC7]

def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_], TC6[_]](rightMatcherFactory: MatcherFactory5[U, TC2, TC3, TC4, TC5, TC6]): MatcherFactory6[U, TC1, TC2, TC3, TC4, TC5, TC6]

def or[U <: SC, TC2[_], TC3[_], TC4[_], TC5[_]](rightMatcherFactory: MatcherFactory4[U, TC2, TC3, TC4, TC5]): MatcherFactory5[U, TC1, TC2, TC3, TC4, TC5]

def or[U <: SC, TC2[_], TC3[_], TC4[_]](rightMatcherFactory: MatcherFactory3[U, TC2, TC3, TC4]): MatcherFactory4[U, TC1, TC2, TC3, TC4]

def or[U <: SC, TC2[_], TC3[_]](rightMatcherFactory: MatcherFactory2[U, TC2, TC3]): MatcherFactory3[U, TC1, TC2, TC3]

def or[U <: SC, TC2[_]](rightMatcherFactory: MatcherFactory1[U, TC2]): MatcherFactory2[U, TC1, TC2]

def or[U <: SC](rightMatcherFactory: MatcherFactory1[U, TC1]): MatcherFactory1[U, TC1]

def or[U <: SC](rightMatcher: Matcher[U]): MatcherFactory1[U, TC1]