StringShouldWrapper

Instance Constructors

new StringShouldWrapper(leftSideValue: 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 leftSideValue: String

Definition Classes
StringShouldWrapper → StringShouldWrapperForVerb
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def should(notWord: NotWord): ResultOfNotWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string should not have length (3)
       ^
```
Definition Classes
StringShouldWrapper → AnyShouldWrapper
def should(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string should fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
       ^
```
def should(endWithWord: EndWithWord): ResultOfEndWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string should endWith regex ("world")
       ^
```
def should(startWithWord: StartWithWord): ResultOfStartWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string should startWith regex ("hello")
       ^
```
def should(includeWord: IncludeWord): ResultOfIncludeWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string should include regex ("hi")
       ^
```
def should(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" should 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 leftSideValue, the verb string "should", and the ResultOfAfterWordApplication passed to should.
Definition Classes
StringShouldWrapperForVerb
def should(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)" should { ...
                       ^
```
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 leftSideValue, the verb string "should", and the right by-name parameter transformed into a no-arg function.
Definition Classes
StringShouldWrapperForVerb
def should(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)" should 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 leftSideValue, and returns the result.
Definition Classes
StringShouldWrapperForVerb
def should(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)" should "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 leftSideValue, the verb string "should", and right, and returns the result.
Definition Classes
StringShouldWrapperForVerb
def should(notExist: ResultOfNotExist)(implicit existence: Existence[String]): Unit

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result should be a aMatcher
       ^
```
Definition Classes
AnyShouldWrapper
def should(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 should === (100 +- 1)
       ^
```
Definition Classes
AnyShouldWrapper
def should[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 should === (b)
       ^
```
Definition Classes
AnyShouldWrapper
def should[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 should (equal (expected) and have length 3)
       ^
```
Definition Classes
AnyShouldWrapper
def should[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 should equal (3)
       ^
```
Definition Classes
AnyShouldWrapper
def should(rightMatcherX1: Matcher[String]): Unit

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result should be (3)
       ^
```
Definition Classes
AnyShouldWrapper
def shouldBe[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 shouldBe an (excellentRead)
                   ^
```
Definition Classes
AnyShouldWrapper
def shouldBe[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 shouldBe a (goodRead)
                   ^
```
Definition Classes
AnyShouldWrapper
def shouldBe(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 shouldBe excellentRead
                   ^
```
Definition Classes
AnyShouldWrapper
def shouldBe(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[String, AnyRef]): Unit

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

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

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

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

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

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

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

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

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result shouldBe 7.1 +- 0.2
       ^
```
Definition Classes
AnyShouldWrapper
def shouldBe(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 shouldBe odd
  ^
```
Definition Classes
AnyShouldWrapper
def shouldBe(comparison: ResultOfGreaterThanOrEqualToComparison[String]): Unit

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

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

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

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
a shouldEqual b
  ^
```
Definition Classes
AnyShouldWrapper
def shouldNot(includeWord: IncludeWord): ResultOfIncludeWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string shouldNot include regex ("hi")
       ^
```
def shouldNot(endWithWord: EndWithWord): ResultOfEndWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string shouldNot endWith regex ("world")
       ^
```
def shouldNot(startWithWord: StartWithWord): ResultOfStartWithWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string shouldNot startWith regex ("hello")
       ^
```
def shouldNot(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string shouldNot fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
       ^
```
def shouldNot(existWord: ExistWord)(implicit existence: Existence[String]): Unit

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result shouldNot have length (3)
       ^{result shouldNot have size (3)}
exception shouldNot have message ("file not found")
          ^
```
Definition Classes
AnyShouldWrapper
def shouldNot[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 shouldNot (be readable)
       ^
```
Definition Classes
AnyShouldWrapper
def shouldNot(rightMatcherX1: Matcher[String]): Unit

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result shouldNot be (3)
       ^
```
Definition Classes
AnyShouldWrapper
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 should 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 should fullyMatch regex ("a(b*)(c*)" withGroups ("bb", "cc"))
                                            ^
```

final class StringShouldWrapper extends AnyShouldWrapper[String] with StringShouldWrapperForVerb

Instance Constructors

new StringShouldWrapper(leftSideValue: 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 leftSideValue: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def should(notWord: NotWord): ResultOfNotWordForString

def should(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

def should(endWithWord: EndWithWord): ResultOfEndWithWordForString

def should(startWithWord: StartWithWord): ResultOfStartWithWordForString

def should(includeWord: IncludeWord): ResultOfIncludeWordForString

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def shouldBe(right: Any): Unit

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

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

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

def shouldNot(includeWord: IncludeWord): ResultOfIncludeWordForString

def shouldNot(endWithWord: EndWithWord): ResultOfEndWithWordForString

def shouldNot(startWithWord: StartWithWord): ResultOfStartWithWordForString

def shouldNot(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

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

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

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

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

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

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

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

def toString(): String

final def wait(): Unit

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