StringMustWrapper

Instance Constructors

new StringMustWrapper(leftSideString: String)

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
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
val leftSideString: String

Definition Classes
StringMustWrapper → StringMustWrapperForVerb
def must(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
       ^
```
def must(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit fun: (String, String, ResultOfAfterWordApplication) ⇒ Unit): Unit

Supports the registration of subject descriptions with after words in WordSpec and fixture.WordSpec.
Supports the registration of subject descriptions with after words in WordSpec and fixture.WordSpec.
For example, this method enables syntax such as the following in WordSpec and fixture.WordSpec:
```
def provide = afterWord("provide")

"The ScalaTest Matchers DSL" must provide {
                             ^
```
WordSpec passes in a function via the implicit parameter that takes two strings and a ResultOfAfterWordApplication and results in Unit. This method simply invokes this function, passing in leftSideString, the verb string "must", and the ResultOfAfterWordApplication passed to must.
Definition Classes
StringMustWrapperForVerb
def must(right: ⇒ Unit)(implicit fun: StringVerbBlockRegistration): Unit

Supports the registration of subject descriptions in WordSpec and fixture.WordSpec.
Supports the registration of subject descriptions in WordSpec and fixture.WordSpec.
For example, this method enables syntax such as the following in WordSpec and fixture.WordSpec:
```
"A Stack (when empty)" must { ...
                       ^
```
WordSpec passes in a function via the implicit parameter of type StringVerbBlockRegistration, a function that takes two strings and a no-arg function and results in Unit. This method simply invokes this function, passing in leftSideString, the verb string "must", and the right by-name parameter transformed into a no-arg function.
Definition Classes
StringMustWrapperForVerb
def must(right: BehaveWord)(implicit fun: (String) ⇒ BehaveWord): BehaveWord

Supports shared test registration in FlatSpec and fixture.FlatSpec.
Supports shared test registration in FlatSpec and fixture.FlatSpec.
For example, this method enables syntax such as the following in FlatSpec and fixture.FlatSpec:
```
"A Stack (with one item)" must behave like nonEmptyStack(stackWithOneItem, lastValuePushed)
                          ^
```
FlatSpec and fixture.FlatSpec passes in a function via the implicit parameter that takes a string and results in a BehaveWord. This method simply invokes this function, passing in leftSideString, and returns the result.
Definition Classes
StringMustWrapperForVerb
def must(right: String)(implicit fun: (String, String, String) ⇒ ResultOfStringPassedToVerb): ResultOfStringPassedToVerb

Supports test registration in FlatSpec and fixture.FlatSpec.
Supports test registration in FlatSpec and fixture.FlatSpec.
For example, this method enables syntax such as the following in FlatSpec and fixture.FlatSpec:
```
"A Stack (when empty)" must "be empty" in { ... }
                       ^
```
FlatSpec passes in a function via the implicit parameter that takes three strings and results in a ResultOfStringPassedToVerb. This method simply invokes this function, passing in leftSideString, the verb string "must", and right, and returns the result.
Definition Classes
StringMustWrapperForVerb
def must(endWithWord: EndWithWord)(implicit ev: <:<[String, String]): ResultOfEndWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must endWith regex ("world")
       ^
```
Definition Classes
AnyMustWrapper
def must(startWithWord: StartWithWord)(implicit ev: <:<[String, String]): ResultOfStartWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must startWith regex ("hello")
       ^
```
Definition Classes
AnyMustWrapper
def must(includeWord: IncludeWord)(implicit ev: <:<[String, String]): ResultOfIncludeWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must include regex ("hi")
       ^
```
Definition Classes
AnyMustWrapper
def must(notExist: ResultOfNotExist)(implicit existence: Existence[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
file must not (exist)
     ^
```
Definition Classes
AnyMustWrapper
def must(existWord: ExistWord)(implicit existence: Existence[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
file must exist
     ^
```
Definition Classes
AnyMustWrapper
def must(containWord: ContainWord): ResultOfContainWord[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
xs must contain oneOf (1, 2, 3)
   ^
```
Definition Classes
AnyMustWrapper
def must(haveWord: HaveWord): ResultOfHaveWordForExtent[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must have length (3)
       ^{result must have size (3)}
```
Definition Classes
AnyMustWrapper
def must(beWord: BeWord): ResultOfBeWordForAny[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must be a aMatcher
       ^
```
Definition Classes
AnyMustWrapper
def must(inv: TripleEqualsInvocationOnSpread[String])(implicit ev: Numeric[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must === (100 +- 1)
       ^
```
Definition Classes
AnyMustWrapper
def must[U](inv: TripleEqualsInvocation[U])(implicit constraint: Constraint[String, U]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
a must === (b)
       ^
```
Definition Classes
AnyMustWrapper
def must(notWord: NotWord): ResultOfNotWordForAny[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must not equal (3)
       ^
```
Definition Classes
AnyMustWrapper
def must[TYPECLASS1[_], TYPECLASS2[_]](rightMatcherFactory2: MatcherFactory2[String, TYPECLASS1, TYPECLASS2])(implicit typeClass1: TYPECLASS1[String], typeClass2: TYPECLASS2[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must (equal (expected) and have length 3)
       ^
```
Definition Classes
AnyMustWrapper
def must[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[String, TYPECLASS1])(implicit typeClass1: TYPECLASS1[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must equal (3)
       ^
```
Definition Classes
AnyMustWrapper
def must(rightMatcherX1: Matcher[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result must be (3)
       ^
```
Definition Classes
AnyMustWrapper
def mustBe[U >: String](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[String, AnyRef]): Unit

This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:
This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:
```
programmingInScala mustBe an (excellentRead)
                   ^
```
Definition Classes
AnyMustWrapper
def mustBe[U >: String](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[String, AnyRef]): Unit

This method enables the following syntax, where goodRead refers to a BePropertyMatcher[Book]:
This method enables the following syntax, where goodRead refers to a BePropertyMatcher[Book]:
```
programmingInScala mustBe a (goodRead)
                   ^
```
Definition Classes
AnyMustWrapper
def mustBe(bePropertyMatcher: BePropertyMatcher[String])(implicit ev: <:<[String, AnyRef]): Unit

This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:
This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:
```
programmingInScala mustBe excellentRead
                   ^
```
Definition Classes
AnyMustWrapper
def mustBe(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

This method enables the following syntax:
This method enables the following syntax:
```
list mustBe an ('empty)
     ^
```
Definition Classes
AnyMustWrapper
def mustBe(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

This method enables the following syntax:
This method enables the following syntax:
```
list mustBe a ('empty)
     ^
```
Definition Classes
AnyMustWrapper
def mustBe(symbol: Symbol)(implicit toAnyRef: <:<[String, AnyRef]): Unit

This method enables the following syntax:
This method enables the following syntax:
```
list mustBe 'empty
     ^
```
Definition Classes
AnyMustWrapper
def mustBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe theSameInstanceAs (anotherObject)
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: Null)(implicit ev: <:<[String, AnyRef]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe null
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: DefinedWord)(implicit definition: Definition[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe defined
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: EmptyWord)(implicit emptiness: Emptiness[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe empty
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: WritableWord)(implicit writability: Writability[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe writable
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: ReadableWord)(implicit readability: Readability[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe readable
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(anType: ResultOfAnTypeInvocation[_]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
aDouble mustBe an [Book]
        ^
```
Definition Classes
AnyMustWrapper
def mustBe(aType: ResultOfATypeInvocation[_]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
aDouble mustBe a [Book]
        ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: SortedWord)(implicit sortable: Sortable[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe sorted
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(spread: Spread[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustBe 7.1 +- 0.2
       ^
```
Definition Classes
AnyMustWrapper
def mustBe(beMatcher: BeMatcher[String]): Unit

This method enables the following syntax, where odd refers to a BeMatcher[Int]:
This method enables the following syntax, where odd refers to a BeMatcher[Int]:
```
testing
1 mustBe odd
  ^
```
Definition Classes
AnyMustWrapper
def mustBe(comparison: ResultOfGreaterThanOrEqualToComparison[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
8 mustBe >= (7)
  ^
```
Definition Classes
AnyMustWrapper
def mustBe(comparison: ResultOfLessThanOrEqualToComparison[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
5 mustBe <= (7)
  ^
```
Definition Classes
AnyMustWrapper
def mustBe(comparison: ResultOfGreaterThanComparison[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
8 mustBe > (7)
  ^
```
Definition Classes
AnyMustWrapper
def mustBe(comparison: ResultOfLessThanComparison[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
5 mustBe < (7)
  ^
```
Definition Classes
AnyMustWrapper
def mustBe(right: Any): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
aDouble mustBe 8.8
        ^
```
Definition Classes
AnyMustWrapper
def mustEqual(right: Null)(implicit ev: <:<[String, AnyRef]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustEqual null
       ^
```
Definition Classes
AnyMustWrapper
def mustEqual(spread: Spread[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustEqual 7.1 +- 0.2
       ^
```
Definition Classes
AnyMustWrapper
def mustEqual(right: Any)(implicit equality: Equality[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
a mustEqual b
  ^
```
Definition Classes
AnyMustWrapper
def mustNot(compileWord: CompileWord): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string mustNot compile
       ^
```
Annotations
@macroImpl()
def mustNot(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string mustNot fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
       ^
```
def mustNot(includeWord: IncludeWord)(implicit ev: <:<[String, String]): ResultOfIncludeWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string mustNot include regex ("hi")
       ^
```
Definition Classes
AnyMustWrapper
def mustNot(endWithWord: EndWithWord)(implicit ev: <:<[String, String]): ResultOfEndWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string mustNot endWith regex ("world")
       ^
```
Definition Classes
AnyMustWrapper
def mustNot(startWithWord: StartWithWord)(implicit ev: <:<[String, String]): ResultOfStartWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string mustNot startWith regex ("hello")
       ^
```
Definition Classes
AnyMustWrapper
def mustNot(existWord: ExistWord)(implicit existence: Existence[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
file mustNot exist
     ^
```
Definition Classes
AnyMustWrapper
def mustNot(contain: ContainWord): ResultOfContainWord[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
xs mustNot contain (oneOf (1, 2, 3))
   ^
```
Definition Classes
AnyMustWrapper
def mustNot(haveWord: HaveWord): ResultOfHaveWordForExtent[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustNot have length (3)
       ^{result mustNot have size (3)}
exception mustNot have message ("file not found")
          ^
```
Definition Classes
AnyMustWrapper
def mustNot[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[String, TYPECLASS1])(implicit typeClass1: TYPECLASS1[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustNot (be readable)
       ^
```
Definition Classes
AnyMustWrapper
def mustNot(rightMatcherX1: Matcher[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustNot (be (3))
       ^
```
Definition Classes
AnyMustWrapper
def mustNot(beWord: BeWord): ResultOfBeWordForAny[String]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result mustNot be (3)
       ^
```
Definition Classes
AnyMustWrapper
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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()
def withGroup(group: String): RegexWithGroups

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must fullyMatch regex ("a(b*)c" withGroup "bb")
                                         ^
```
def withGroups(groups: String*): RegexWithGroups

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must fullyMatch regex ("a(b*)(c*)" withGroups ("bb", "cc"))
                                            ^
```

final class StringMustWrapper extends AnyMustWrapper[String] with StringMustWrapperForVerb

Instance Constructors

new StringMustWrapper(leftSideString: String)

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

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

val leftSideString: String

def must(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

def must(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit fun: (String, String, ResultOfAfterWordApplication) ⇒ Unit): Unit

def must(right: ⇒ Unit)(implicit fun: StringVerbBlockRegistration): Unit

def must(right: BehaveWord)(implicit fun: (String) ⇒ BehaveWord): BehaveWord

def must(right: String)(implicit fun: (String, String, String) ⇒ ResultOfStringPassedToVerb): ResultOfStringPassedToVerb

def must(endWithWord: EndWithWord)(implicit ev: <:<[String, String]): ResultOfEndWithWordForString

def must(startWithWord: StartWithWord)(implicit ev: <:<[String, String]): ResultOfStartWithWordForString

def must(includeWord: IncludeWord)(implicit ev: <:<[String, String]): ResultOfIncludeWordForString

def must(notExist: ResultOfNotExist)(implicit existence: Existence[String]): Unit

def must(existWord: ExistWord)(implicit existence: Existence[String]): Unit

def must(containWord: ContainWord): ResultOfContainWord[String]

def must(haveWord: HaveWord): ResultOfHaveWordForExtent[String]

def must(beWord: BeWord): ResultOfBeWordForAny[String]

def must(inv: TripleEqualsInvocationOnSpread[String])(implicit ev: Numeric[String]): Unit

def must[U](inv: TripleEqualsInvocation[U])(implicit constraint: Constraint[String, U]): Unit

def must(notWord: NotWord): ResultOfNotWordForAny[String]

def must[TYPECLASS1[_], TYPECLASS2[_]](rightMatcherFactory2: MatcherFactory2[String, TYPECLASS1, TYPECLASS2])(implicit typeClass1: TYPECLASS1[String], typeClass2: TYPECLASS2[String]): Unit

def must[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[String, TYPECLASS1])(implicit typeClass1: TYPECLASS1[String]): Unit

def must(rightMatcherX1: Matcher[String]): Unit

def mustBe[U >: String](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[String, AnyRef]): Unit

def mustBe[U >: String](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[String, AnyRef]): Unit

def mustBe(bePropertyMatcher: BePropertyMatcher[String])(implicit ev: <:<[String, AnyRef]): Unit

def mustBe(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

def mustBe(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

def mustBe(symbol: Symbol)(implicit toAnyRef: <:<[String, AnyRef]): Unit

def mustBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

def mustBe(right: Null)(implicit ev: <:<[String, AnyRef]): Unit

def mustBe(right: DefinedWord)(implicit definition: Definition[String]): Unit

def mustBe(right: EmptyWord)(implicit emptiness: Emptiness[String]): Unit

def mustBe(right: WritableWord)(implicit writability: Writability[String]): Unit

def mustBe(right: ReadableWord)(implicit readability: Readability[String]): Unit

def mustBe(anType: ResultOfAnTypeInvocation[_]): Unit

def mustBe(aType: ResultOfATypeInvocation[_]): Unit

def mustBe(right: SortedWord)(implicit sortable: Sortable[String]): Unit

def mustBe(spread: Spread[String]): Unit

def mustBe(beMatcher: BeMatcher[String]): Unit

def mustBe(comparison: ResultOfGreaterThanOrEqualToComparison[String]): Unit

def mustBe(comparison: ResultOfLessThanOrEqualToComparison[String]): Unit

def mustBe(comparison: ResultOfGreaterThanComparison[String]): Unit

def mustBe(comparison: ResultOfLessThanComparison[String]): Unit

def mustBe(right: Any): Unit

def mustEqual(right: Null)(implicit ev: <:<[String, AnyRef]): Unit

def mustEqual(spread: Spread[String]): Unit

def mustEqual(right: Any)(implicit equality: Equality[String]): Unit

def mustNot(compileWord: CompileWord): Unit

def mustNot(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

def mustNot(includeWord: IncludeWord)(implicit ev: <:<[String, String]): ResultOfIncludeWordForString

def mustNot(endWithWord: EndWithWord)(implicit ev: <:<[String, String]): ResultOfEndWithWordForString

def mustNot(startWithWord: StartWithWord)(implicit ev: <:<[String, String]): ResultOfStartWithWordForString

def mustNot(existWord: ExistWord)(implicit existence: Existence[String]): Unit

def mustNot(contain: ContainWord): ResultOfContainWord[String]

def mustNot(haveWord: HaveWord): ResultOfHaveWordForExtent[String]

def mustNot[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[String, TYPECLASS1])(implicit typeClass1: TYPECLASS1[String]): Unit

def mustNot(rightMatcherX1: Matcher[String]): Unit

def mustNot(beWord: BeWord): ResultOfBeWordForAny[String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit