StringMustWrapper

Instance Constructors

new StringMustWrapper(leftSideString: String, pos: Position, prettifier: Prettifier)

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

Definition Classes
StringMustWrapper → StringMustWrapperForVerb
val leftSideValue: String

Definition Classes
AnyMustWrapper
def must(compileWord: CompileWord)(implicit pos: Position): Assertion

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string must compile
       ^
```
Annotations
@macroImpl( ... )
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 swawr: SubjectWithAfterWordRegistration): Unit

Definition Classes
StringMustWrapperForVerb
def must(right: ⇒ Unit)(implicit fun: StringVerbBlockRegistration): Unit

Definition Classes
StringMustWrapperForVerb
def must(right: BehaveWord)(implicit svbli: StringVerbBehaveLikeInvocation): BehaveWord

Definition Classes
StringMustWrapperForVerb
def must(right: String)(implicit svsi: StringVerbStringInvocation): ResultOfStringPassedToVerb

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]): Assertion

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]): Assertion

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]): Assertion

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: CanEqual[String, U]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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[_]): Assertion

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

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

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

This method enables syntax such as the following:
This method enables syntax such as the following:
```
a mustEqual b
  ^
```
Definition Classes
AnyMustWrapper
def mustNot(typeCheckWord: TypeCheckWord)(implicit pos: Position): Assertion

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string mustNot typeCheck
       ^
```
Annotations
@macroImpl( ... )
def mustNot(compileWord: CompileWord)(implicit pos: Position): Assertion

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]): Assertion

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]): Assertion

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]): Assertion

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, pos: Position, prettifier: Prettifier)

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

val leftSideValue: String

def must(compileWord: CompileWord)(implicit pos: Position): Assertion

def must(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

def must(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit swawr: SubjectWithAfterWordRegistration): Unit

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

def must(right: BehaveWord)(implicit svbli: StringVerbBehaveLikeInvocation): BehaveWord

def must(right: String)(implicit svsi: StringVerbStringInvocation): 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]): Assertion

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

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]): Assertion

def must[U](inv: TripleEqualsInvocation[U])(implicit constraint: CanEqual[String, U]): Assertion

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def mustBe(right: Any): Assertion

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

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

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

def mustNot(typeCheckWord: TypeCheckWord)(implicit pos: Position): Assertion

def mustNot(compileWord: CompileWord)(implicit pos: Position): Assertion

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]): Assertion

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

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

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

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

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit