StringWillWrapper

Instance Constructors

new StringWillWrapper(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
StringWillWrapper → StringWillWrapperForVerb
val leftSideValue: String

Definition Classes
AnyWillWrapper
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 will(compileWord: CompileWord)(implicit prettifier: Prettifier, pos: Position): Fact

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string will fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
       ^
```
def will(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit swawr: SubjectWithAfterWordRegistration): 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" will 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 "will", and the ResultOfAfterWordApplication passed to will.
Definition Classes
StringWillWrapperForVerb
def will(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)" will { ...
                       ^
```
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 "will", and the right by-name parameter transformed into a no-arg function.
Definition Classes
StringWillWrapperForVerb
def will(right: BehaveWord)(implicit svbli: StringVerbBehaveLikeInvocation): 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)" will 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
StringWillWrapperForVerb
def will(right: String)(implicit svsi: StringVerbStringInvocation): 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)" will "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 "will", and right, and returns the result.
Definition Classes
StringWillWrapperForVerb
def will(endWithWord: EndWithWord)(implicit ev: <:<[String, String]): ResultOfEndWithWordForString

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
file will exist
     ^
```
Definition Classes
AnyWillWrapper
def will(containWord: ContainWord): FactResultOfContainWord[String]

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result will === (100 +- 1)
       ^
```
Definition Classes
AnyWillWrapper
def will[U](inv: TripleEqualsInvocation[U])(implicit constraint: CanEqual[String, U]): Fact

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result will be (3)
       ^
```
Definition Classes
AnyWillWrapper
def willBe[U >: String](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[String, AnyRef]): Fact

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 willBe an (excellentRead)
                   ^
```
Definition Classes
AnyWillWrapper
def willBe[U >: String](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[String, AnyRef]): Fact

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 willBe a (goodRead)
                   ^
```
Definition Classes
AnyWillWrapper
def willBe(bePropertyMatcher: BePropertyMatcher[String])(implicit ev: <:<[String, AnyRef]): Fact

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 willBe excellentRead
                   ^
```
Definition Classes
AnyWillWrapper
def willBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[String, AnyRef]): Fact

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

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result willBe readable
       ^
```
Definition Classes
AnyWillWrapper
def willBe(anType: FactResultOfAnTypeInvocation[_]): Fact

This method enables syntax such as the following:
This method enables syntax such as the following:
```
aDouble willBe an [Book]
        ^
```
Definition Classes
AnyWillWrapper
Annotations
@macroImpl( ... )
def willBe(aType: FactResultOfATypeInvocation[_]): Fact

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result willBe sorted
       ^
```
Definition Classes
AnyWillWrapper
def willBe(spread: Spread[String]): Fact

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

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 willBe odd
  ^
```
Definition Classes
AnyWillWrapper
def willBe(comparison: ResultOfGreaterThanOrEqualToComparison[String]): Fact

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
5 willBe < (7)
  ^
```
Definition Classes
AnyWillWrapper
def willBe(right: Any): Fact

This method enables syntax such as the following:
This method enables syntax such as the following:
```
aDouble willBe 8.8
        ^
```
Definition Classes
AnyWillWrapper
def willEqual(right: Null)(implicit ev: <:<[String, AnyRef]): Fact

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result willEqual null
       ^
```
Definition Classes
AnyWillWrapper
def willEqual(spread: Spread[String]): Fact

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
a willEqual b
  ^
```
Definition Classes
AnyWillWrapper
def willNot(typeCheckWord: TypeCheckWord)(implicit prettifier: Prettifier, pos: Position): Fact

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string willNot typeCheck
       ^
```
Annotations
@macroImpl( ... )
def willNot(compileWord: CompileWord)(implicit prettifier: Prettifier, pos: Position): Fact

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

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
file willNot exist
     ^
```
Definition Classes
AnyWillWrapper
def willNot(contain: ContainWord): FactResultOfContainWord[String]

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

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

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

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

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result willNot be (3)
       ^
```
Definition Classes
AnyWillWrapper
def withGroup(group: String): RegexWithGroups

This method enables syntax such as the following:
This method enables syntax such as the following:
```
string will 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 will fullyMatch regex ("a(b*)(c*)" withGroups ("bb", "cc"))
                                            ^
```

final class StringWillWrapper extends AnyWillWrapper[String] with StringWillWrapperForVerb

Instance Constructors

new StringWillWrapper(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

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

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

final def wait(arg0: Long): Unit

def will(compileWord: CompileWord)(implicit prettifier: Prettifier, pos: Position): Fact

def will(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

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

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

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

def will(right: String)(implicit svsi: StringVerbStringInvocation): ResultOfStringPassedToVerb

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

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

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

def will(notExist: ResultOfNotExist)(implicit existence: Existence[String]): Fact

def will(existWord: ExistWord)(implicit existence: Existence[String]): Fact

def will(containWord: ContainWord): FactResultOfContainWord[String]

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

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

def will(inv: TripleEqualsInvocationOnSpread[String])(implicit ev: Numeric[String]): Fact

def will[U](inv: TripleEqualsInvocation[U])(implicit constraint: CanEqual[String, U]): Fact

def will(notWord: NotWord): FactResultOfNotWordForAny[String]

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

def will[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[String, TYPECLASS1])(implicit typeClass1: TYPECLASS1[String]): Fact

def will(rightMatcherX1: Matcher[String]): Fact

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

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

def willBe(bePropertyMatcher: BePropertyMatcher[String])(implicit ev: <:<[String, AnyRef]): Fact

def willBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[String, AnyRef]): Fact

def willBe(right: Null)(implicit ev: <:<[String, AnyRef]): Fact

def willBe(right: DefinedWord)(implicit definition: Definition[String]): Fact

def willBe(right: EmptyWord)(implicit emptiness: Emptiness[String]): Fact

def willBe(right: WritableWord)(implicit writability: Writability[String]): Fact

def willBe(right: ReadableWord)(implicit readability: Readability[String]): Fact

def willBe(anType: FactResultOfAnTypeInvocation[_]): Fact

def willBe(aType: FactResultOfATypeInvocation[_]): Fact

def willBe(right: SortedWord)(implicit sortable: Sortable[String]): Fact

def willBe(spread: Spread[String]): Fact

def willBe(beMatcher: BeMatcher[String]): Fact

def willBe(comparison: ResultOfGreaterThanOrEqualToComparison[String]): Fact

def willBe(comparison: ResultOfLessThanOrEqualToComparison[String]): Fact

def willBe(comparison: ResultOfGreaterThanComparison[String]): Fact

def willBe(comparison: ResultOfLessThanComparison[String]): Fact

def willBe(right: Any): Fact

def willEqual(right: Null)(implicit ev: <:<[String, AnyRef]): Fact

def willEqual(spread: Spread[String]): Fact

def willEqual(right: Any)(implicit equality: Equality[String]): Fact

def willNot(typeCheckWord: TypeCheckWord)(implicit prettifier: Prettifier, pos: Position): Fact

def willNot(compileWord: CompileWord)(implicit prettifier: Prettifier, pos: Position): Fact

def willNot(fullyMatchWord: FullyMatchWord): ResultOfFullyMatchWordForString

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

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

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

def willNot(existWord: ExistWord)(implicit existence: Existence[String]): Fact

def willNot(contain: ContainWord): FactResultOfContainWord[String]

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

def willNot[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[String, TYPECLASS1])(implicit typeClass1: TYPECLASS1[String]): Fact