WillMatchers

Type Members

final class AWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class AnWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
sealed class AnyWillWrapper[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
class DecidedByEquality[A] extends Equality[A]

Definition Classes
Explicitly
class DecidedWord extends AnyRef

Definition Classes
Explicitly
class DeterminedByEquivalence[T] extends Equivalence[T]

Definition Classes
Explicitly
class DeterminedWord extends AnyRef

Definition Classes
Explicitly
class ExpectationsHelper extends AnyRef

Definition Classes
Expectations
final class FactResultOfContainWordForCollectedAny[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class KeyWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class PlusOrMinusWrapper[T] extends AnyRef

Definition Classes
Tolerance
final class RegexWord extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class RegexWrapper extends AnyRef

This class is part of the ScalaTest matchers DSL.
class ResultOfBeWordForAny[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfCollectedAny[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfEndWithWordForCollectedString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfEndWithWordForString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfFullyMatchWordForCollectedString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfFullyMatchWordForString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfHaveWordForExtent[A] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfIncludeWordForCollectedString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfIncludeWordForString extends AnyRef

This class is part of the ScalaTest matchers DSL.
sealed class ResultOfNotWordForCollectedAny[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfProduceInvocation[T] extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfStartWithWordForCollectedString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ResultOfStartWithWordForString extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class StringWillWrapper extends AnyWillWrapper[String] with StringWillWrapperForVerb

This class is part of the ScalaTest matchers DSL.
trait StringWillWrapperForVerb extends AnyRef

This class supports the syntax of FlatSpec, WordSpec, fixture.FlatSpec, and fixture.WordSpec.
class TheAfterWord extends AnyRef

Definition Classes
Explicitly
final class TheSameInstanceAsPhrase extends AnyRef

This class is part of the ScalaTest matchers DSL.
final class ValueWord extends AnyRef

This class is part of the ScalaTest matchers DSL.

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
def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]

This method enables the following syntax:
This method enables the following syntax:
```
num will (not be < (10) and not be > (17))
                   ^
```
Definition Classes
WillMatchers
def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]

This method enables the following syntax:
This method enables the following syntax:
```
num will (not be <= (10) and not be > (17))
                   ^
```
Definition Classes
WillMatchers
final def ==(arg0: AnyRef): Boolean

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

Definition Classes
Any
def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]

This method enables the following syntax:
This method enables the following syntax:
```
num will (not be > (10) and not be < (7))
                   ^
```
Definition Classes
WillMatchers
def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]

This method enables the following syntax:
This method enables the following syntax:
```
num will (not be >= (10) and not be < (7))
                   ^
```
Definition Classes
WillMatchers
def a[T](implicit arg0: ClassTag[T]): FactResultOfATypeInvocation[T]

This method enables the following syntax:
This method enables the following syntax:
```
a [RuntimeException] will be thrownBy { ... }
^
```
Definition Classes
WillMatchers
val a: AWord

This field enables the following syntax:
This field enables the following syntax:
```
badBook will not be a ('goodRead)
                      ^
```
Definition Classes
WillMatchers
val after: TheAfterWord

Definition Classes
Explicitly
def all(xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
all(str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
all(jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
all(xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (allElementsOf(1, 2))
                              ^
```
Definition Classes
WillMatchers
def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfAllOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (allOf(1, 2))
                              ^
```
Definition Classes
WillMatchers
def an[T](implicit arg0: ClassTag[T]): FactResultOfAnTypeInvocation[T]

This method enables the following syntax:
This method enables the following syntax:
```
an [Exception] will be thrownBy { ... }
^
```
Definition Classes
WillMatchers
val an: AnWord

This field enables the following syntax:
This field enables the following syntax:
```
badBook will not be an (excellentRead)
                      ^
```
Definition Classes
WillMatchers
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
atLeast(1, str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def atLeast[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
atLeast(1, jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
atLeast(1, xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def atLeastOneElementOf(elements: GenTraversable[Any]): ResultOfAtLeastOneElementOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (atLeastOneElementOf (List(1, 2)))
                              ^
```
Definition Classes
WillMatchers
def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfAtLeastOneOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (atLeastOneOf(1, 2))
                              ^
```
Definition Classes
WillMatchers
def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
atMost(3, str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def atMost[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
atMost(3, jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
atMost(3, xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (atMostOneElementOf (List(1, 2)))
                              ^
```
Definition Classes
WillMatchers
def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfAtMostOneOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (atMostOneOf(1, 2))
                              ^
```
Definition Classes
WillMatchers
val be: BeWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
obj will (be theSameInstanceAs (string) and be theSameInstanceAs (string))
            ^
```
Definition Classes
FactMatcherWords
def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
between(1, 3, str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def between[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
between(1, 3, jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
between(1, 3, xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val compile: CompileWord

This field enables the following syntax:
This field enables the following syntax:
```
"val a: String = 1" willNot compile
                              ^
```
Definition Classes
FactMatcherWords
val contain: ContainWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
list will (contain ('a') and have length (7))
             ^
```
Definition Classes
FactMatcherWords
implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

Definition Classes
Tolerance
implicit def convertToAnyWillWrapper[T](o: T): AnyWillWrapper[T]

Implicitly converts an object of type T to a AnyWillWrapper[T], to enable will methods to be invokable on that object.
Implicitly converts an object of type T to a AnyWillWrapper[T], to enable will methods to be invokable on that object.

Definition Classes
WillMatchers
implicit def convertToRegexWrapper(o: Regex): RegexWrapper

Implicitly converts an object of type scala.util.matching.Regex to a RegexWrapper, to enable withGroup and withGroups methods to be invokable on that object.
Implicitly converts an object of type scala.util.matching.Regex to a RegexWrapper, to enable withGroup and withGroups methods to be invokable on that object.

Definition Classes
WillMatchers
implicit def convertToStringWillWrapper(o: String): StringWillWrapper

Implicitly converts an object of type java.lang.String to a StringWillWrapper, to enable will methods to be invokable on that object.
Implicitly converts an object of type java.lang.String to a StringWillWrapper, to enable will methods to be invokable on that object.

Definition Classes
WillMatchers → WillVerb
val decided: DecidedWord

Definition Classes
Explicitly
val defined: DefinedWord

This field enables the following syntax:
This field enables the following syntax:
```
seq will be (defined)
              ^
```
Definition Classes
FactMatcherWords
def definedAt[T](right: T): ResultOfDefinedAt[T]

This method enables the following syntax:
This method enables the following syntax:
```
list will (not be definedAt (7) and not be definedAt (9))
                    ^
```
Definition Classes
WillMatchers
val determined: DeterminedWord

Definition Classes
Explicitly
val empty: EmptyWord

This field enables the following syntax:
This field enables the following syntax:
```
list will be (empty)
                ^
```
Definition Classes
FactMatcherWords
val endWith: EndWithWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
string will (endWith ("ago") and include ("score"))
               ^
```
Definition Classes
FactMatcherWords
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(o: Null): Matcher[AnyRef]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result will equal (null)
              ^
```
Definition Classes
WillMatchers
def equal[T](spread: Spread[T]): Matcher[T]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
result will equal (100 +- 1)
              ^
```
Definition Classes
WillMatchers
def equal(right: Any): MatcherFactory1[Any, Equality]

This method enables the following syntax:
This method enables the following syntax:
```
result will equal (7)
              ^
```
The left will equal (right) syntax works by calling == on the left value, passing in the right value, on every type except arrays. If both left and right are arrays, deep will be invoked on both left and right before comparing them with ==. Thus, even though this expression will yield false, because Array's equals method compares object identity:
```
Array(1, 2) == Array(1, 2) // yields false
```
The following expression will not result in a TestFailedException, because ScalaTest will compare the two arrays structurally, taking into consideration the equality of the array's contents:
```
Array(1, 2) will equal (Array(1, 2)) // succeeds (i.e., does not throw TestFailedException)
```
If you ever do want to verify that two arrays are actually the same object (have the same identity), you can use the be theSameInstanceAs syntax.
Definition Classes
FactMatcherWords
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def every(xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
every(str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def every[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
every(jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
every(xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
exactly(str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def exactly[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
exactly(jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
exactly(xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
val exist: ExistWord

This field enables the following syntax:
This field enables the following syntax:
```
file will exist
            ^
```
Definition Classes
FactMatcherWords
def expect(expression: Boolean): Fact

Definition Classes
Expectations
Annotations
@macroImpl( ... )
def expectCompiles(code: String): Fact

Definition Classes
Expectations
Annotations
@macroImpl( ... )
def expectDoesNotCompile(code: String): Fact

Definition Classes
Expectations
Annotations
@macroImpl( ... )
def expectResult(expected: Any)(actual: Any): Fact

Definition Classes
Expectations
def expectThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T]): Expectation

Definition Classes
Expectations
def expectTypeError(code: String): Fact

Definition Classes
Expectations
Annotations
@macroImpl( ... )
val expectationsHelper: ExpectationsHelper

Definition Classes
Expectations
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val fullyMatch: FullyMatchWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
string will (fullyMatch regex ("Hel*o, wor.d") and not have length (99))
               ^
```
Definition Classes
FactMatcherWords
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
val have: HaveWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
list will (have length (3) and not contain ('a'))
             ^
```
Definition Classes
FactMatcherWords
def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfInOrderApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (inOrder(1, 2))
                              ^
```
Definition Classes
WillMatchers
def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (inOrderElementsOf List(1, 2))
                              ^
```
Definition Classes
WillMatchers
def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfInOrderOnlyApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (inOrderOnly(1, 2))
                              ^
```
Definition Classes
WillMatchers
val include: IncludeWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
string will (include ("hope") and not startWith ("no"))
               ^
```
Definition Classes
FactMatcherWords
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val key: KeyWord

This field enables the following syntax:
This field enables the following syntax:
```
map will not contain key (10)
                       ^
```
Definition Classes
WillMatchers
val length: LengthWord

This field enables the following syntax:
This field enables the following syntax:
```
"hi" will not have length (3)
                     ^
```
Definition Classes
FactMatcherWords
val matchPattern: MatchPatternWord

This field enables the following syntax:
This field enables the following syntax:
```
result will matchPattern { case Person("Bob", _) => }
              ^
```
Definition Classes
FactMatcherWords
def message(expectedMessage: String): ResultOfMessageWordApplication

This method enables the following syntax:
This method enables the following syntax:
```
exception will not have message ("file not found")
                          ^
```
Definition Classes
WillMatchers
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def no(xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

This method enables the following syntax for String:
This method enables the following syntax for String:
```
no(str) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def no[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

This method enables the following syntax for java.util.Map:
This method enables the following syntax for java.util.Map:
```
no(jmap) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

This method enables the following syntax:
This method enables the following syntax:
```
no(xs) will fullymatch regex ("Hel*o world".r)
^
```
Definition Classes
WillMatchers
def noElementsOf(elements: GenTraversable[Any]): ResultOfNoElementsOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (noElementsOf List(1, 2))
                              ^
```
Definition Classes
WillMatchers
val noException: FactExceptionWord

This field enables the following syntax:
This field enables the following syntax:
```
noException will be thrownBy
^
```
Definition Classes
FactMatcherWords
def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfNoneOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (noneOf(1, 2))
                              ^
```
Definition Classes
WillMatchers
val not: NotWord

This field enables syntax like the following:
This field enables syntax like the following:
```
myFile will (not be an (directory) and not have ('name ("foo.bar")))
               ^
```
Definition Classes
FactMatcherWords
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def of[T](implicit ev: ClassTag[T]): ResultOfOfTypeInvocation[T]

This method enables syntax such as the following:
This method enables syntax such as the following:
```
book will have (message ("A TALE OF TWO CITIES") (of [Book]), title ("A Tale of Two Cities"))
                                                    ^
```
Definition Classes
WillMatchers
def oneElementOf(elements: GenTraversable[Any]): ResultOfOneElementOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (oneElementOf (List(1, 2)))
                              ^
```
Definition Classes
WillMatchers
def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfOneOfApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (oneOf(1, 2))
                              ^
```
Definition Classes
WillMatchers
def only(xs: Any*): ResultOfOnlyApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (only(1, 2))
                              ^
```
Definition Classes
WillMatchers
def produce[T](implicit arg0: ClassTag[T]): ResultOfProduceInvocation[T]

This method enables the following syntax:
This method enables the following syntax:
```
evaluating { "hi".charAt(-1) } will produce [StringIndexOutOfBoundsException]
                                      ^
```
Definition Classes
WillMatchers
val readable: ReadableWord

This field enables the following syntax:
This field enables the following syntax:
```
file will be (readable)
                ^
```
Definition Classes
FactMatcherWords
val regex: RegexWord

This field enables the following syntax:
This field enables the following syntax:
```
"eight" will not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""".r)
                              ^
```
Definition Classes
WillMatchers
val size: SizeWord

This field enables the following syntax:
This field enables the following syntax:
```
set will not have size (3)
                    ^
```
Definition Classes
FactMatcherWords
val sorted: SortedWord

This field enables the following syntax:
This field enables the following syntax:
```
seq will be (sorted)
              ^
```
Definition Classes
FactMatcherWords
val startWith: StartWithWord

This field enables syntax such as the following:
This field enables syntax such as the following:
```
string will (startWith ("Four") and include ("year"))
               ^
```
Definition Classes
FactMatcherWords
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def the[T](implicit arg0: ClassTag[T]): ResultOfTheTypeInvocation[T]

This method enables the following syntax:
This method enables the following syntax:
```
the [FileNotFoundException] will be thrownBy { ... }
^
```
Definition Classes
WillMatchers
def theSameElementsAs(xs: GenTraversable[_]): ResultOfTheSameElementsAsApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (theSameElementsAs(List(1, 2, 3)))
                              ^
```
Definition Classes
WillMatchers
def theSameElementsInOrderAs(xs: GenTraversable[_]): ResultOfTheSameElementsInOrderAsApplication

This method enables the following syntax:
This method enables the following syntax:
```
List(1, 2, 3) will contain (theSameElementsInOrderAs(List(1, 2)))
                              ^
```
Definition Classes
WillMatchers
val theSameInstanceAs: TheSameInstanceAsPhrase

This field enables the following syntax:
This field enables the following syntax:
```
oneString will not be theSameInstanceAs (anotherString)
                        ^
```
Definition Classes
WillMatchers
def thrownBy(fun: ⇒ Any): ResultOfThrownByApplication

This method enables the following syntax:
This method enables the following syntax:
```
a [RuntimeException] will be thrownBy {...}
                               ^
```
Definition Classes
WillMatchers
def toString(): String

Definition Classes
AnyRef → Any
val typeCheck: TypeCheckWord

This field enables the following syntax:
This field enables the following syntax:
```
"val a: String = 1" willNot typeCheck
                              ^
```
Definition Classes
FactMatcherWords
val value: ValueWord

This field enables the following syntax:
This field enables the following syntax:
```
map will not contain value (10)
                       ^
```
Definition Classes
WillMatchers
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( ... )
val writable: WritableWord

This field enables the following syntax:
This field enables the following syntax:
```
file will be (writable)
                ^
```
Definition Classes
FactMatcherWords

object WillMatchers extends WillMatchers

Type Members

final class AWord extends AnyRef

final class AnWord extends AnyRef

sealed class AnyWillWrapper[T] extends AnyRef

class DecidedByEquality[A] extends Equality[A]

class DecidedWord extends AnyRef

class DeterminedByEquivalence[T] extends Equivalence[T]

class DeterminedWord extends AnyRef

class ExpectationsHelper extends AnyRef

final class FactResultOfContainWordForCollectedAny[T] extends AnyRef

final class KeyWord extends AnyRef

final class PlusOrMinusWrapper[T] extends AnyRef

final class RegexWord extends AnyRef

final class RegexWrapper extends AnyRef

class ResultOfBeWordForAny[T] extends AnyRef

sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

final class ResultOfCollectedAny[T] extends AnyRef

final class ResultOfEndWithWordForCollectedString extends AnyRef

final class ResultOfEndWithWordForString extends AnyRef

final class ResultOfFullyMatchWordForCollectedString extends AnyRef

final class ResultOfFullyMatchWordForString extends AnyRef

final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

final class ResultOfHaveWordForExtent[A] extends AnyRef

final class ResultOfIncludeWordForCollectedString extends AnyRef

final class ResultOfIncludeWordForString extends AnyRef

sealed class ResultOfNotWordForCollectedAny[T] extends AnyRef

final class ResultOfProduceInvocation[T] extends AnyRef

final class ResultOfStartWithWordForCollectedString extends AnyRef

final class ResultOfStartWithWordForString extends AnyRef

final class StringWillWrapper extends AnyWillWrapper[String] with StringWillWrapperForVerb

trait StringWillWrapperForVerb extends AnyRef

class TheAfterWord extends AnyRef

final class TheSameInstanceAsPhrase extends AnyRef

final class ValueWord extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]

def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]

def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]

def a[T](implicit arg0: ClassTag[T]): FactResultOfATypeInvocation[T]

val a: AWord

val after: TheAfterWord

def all(xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication

def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfAllOfApplication

def an[T](implicit arg0: ClassTag[T]): FactResultOfAnTypeInvocation[T]

val an: AnWord

final def asInstanceOf[T0]: T0

def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

def atLeast[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

def atLeastOneElementOf(elements: GenTraversable[Any]): ResultOfAtLeastOneElementOfApplication

def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfAtLeastOneOfApplication

def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

def atMost[K, V, JMAP[k, v] <: Map[k, v]](num: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication

def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*): ResultOfAtMostOneOfApplication

val be: BeWord

def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String]): ResultOfCollectedAny[Char]

def between[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): ResultOfCollectedAny[Entry[K, V]]

def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]]): ResultOfCollectedAny[E]

def clone(): AnyRef

val compile: CompileWord

val contain: ContainWord

implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

implicit def convertToAnyWillWrapper[T](o: T): AnyWillWrapper[T]

implicit def convertToRegexWrapper(o: Regex): RegexWrapper

implicit def convertToStringWillWrapper(o: String): StringWillWrapper

val decided: DecidedWord

val defined: DefinedWord