org.scalatest

WillMatchers

object WillMatchers extends WillMatchers

Companion object that facilitates the importing of Matchers members as an alternative to mixing it the trait. One use case is to import Matchers members so you can use them in the Scala interpreter.

Linear Supertypes
WillMatchers, Explicitly, FactMatcherWords, WillVerb, Tolerance, Expectations, AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. WillMatchers
  2. WillMatchers
  3. Explicitly
  4. FactMatcherWords
  5. WillVerb
  6. Tolerance
  7. Expectations
  8. AnyRef
  9. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. final class AWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  2. final class AnWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  3. sealed class AnyWillWrapper[T] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  4. class DecidedByEquality[A] extends Equality[A]

    Definition Classes
    Explicitly
  5. class DecidedWord extends AnyRef

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

    Definition Classes
    Explicitly
  7. class DeterminedWord extends AnyRef

    Definition Classes
    Explicitly
  8. final class FactResultOfContainWordForCollectedAny[T] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  9. final class KeyWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  10. final class PlusOrMinusWrapper[T] extends AnyRef

    Definition Classes
    Tolerance
  11. final class RegexWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  12. final class RegexWrapper extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  13. class ResultOfBeWordForAny[T] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  14. sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  15. final class ResultOfCollectedAny[T] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  16. final class ResultOfEndWithWordForCollectedString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  17. final class ResultOfEndWithWordForString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  18. final class ResultOfFullyMatchWordForCollectedString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  19. final class ResultOfFullyMatchWordForString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  20. final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  21. final class ResultOfHaveWordForExtent[A] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  22. final class ResultOfIncludeWordForCollectedString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  23. final class ResultOfIncludeWordForString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  24. final class ResultOfNotWordForCollectedAny[T] extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  25. final class ResultOfStartWithWordForCollectedString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  26. final class ResultOfStartWithWordForString extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  27. final class StringWillWrapper extends AnyWillWrapper[String] with StringWillWrapperForVerb

    This class is part of the ScalaTest matchers DSL.

  28. trait StringWillWrapperForVerb extends AnyRef

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

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

    This class is used in conjunction with an implicit conversion to enable will methods to be invoked on Strings.

    Definition Classes
    WillVerb
  29. class TheAfterWord extends AnyRef

    Definition Classes
    Explicitly
  30. final class TheSameInstanceAsPhrase extends AnyRef

    This class is part of the ScalaTest matchers DSL.

  31. final class ValueWord extends AnyRef

    This class is part of the ScalaTest matchers DSL.

Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. 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
  5. 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
  6. final def ==(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  8. 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
  9. 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
  10. 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
  11. val a: AWord

    This field enables the following syntax:

    This field enables the following syntax:

    badBook will not be a ('goodRead)
                          ^
    

    Definition Classes
    WillMatchers
  12. val after: TheAfterWord

    Definition Classes
    Explicitly
  13. def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  14. def all[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): 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
  15. def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  16. 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
  17. def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  18. 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
  19. val an: AnWord

    This field enables the following syntax:

    This field enables the following syntax:

    badBook will not be an (excellentRead)
                          ^
    

    Definition Classes
    WillMatchers
  20. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  21. def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  22. 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]], prettifier: Prettifier, pos: Position): 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
  23. def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  24. 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
  25. def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  26. def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  27. 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]], prettifier: Prettifier, pos: Position): 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
  28. def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  29. 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
  30. def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  31. 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
  32. def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  33. 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]], prettifier: Prettifier, pos: Position): 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
  34. def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  35. implicit def booleanToFact(expression: Boolean)(implicit prettifier: Prettifier, pos: Position): Fact

    Implicit conversion that makes (x > 0) implies expect(x > -1) syntax works

    Implicit conversion that makes (x > 0) implies expect(x > -1) syntax works

    Definition Classes
    Expectations
    Annotations
    @macroImpl( ... )
  36. def clone(): AnyRef

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

    This field enables the following syntax:

    This field enables the following syntax:

    "val a: String = 1" willNot compile
                                  ^
    

    Definition Classes
    FactMatcherWords
  38. 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
  39. implicit def convertExpectationToAssertion(exp: Expectation): Assertion

    Definition Classes
    Expectations
  40. implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

    Definition Classes
    Tolerance
  41. implicit def convertToAnyWillWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): 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
  42. 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
  43. implicit def convertToStringWillWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): 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
  44. implicit def convertToStringWillWrapperForVerb(o: String)(implicit position: Position): StringWillWrapperForVerb

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

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

    Definition Classes
    WillVerb
  45. val decided: DecidedWord

    Definition Classes
    Explicitly
  46. val defined: DefinedWord

    This field enables the following syntax:

    This field enables the following syntax:

    seq will be (defined)
                  ^
    

    Definition Classes
    FactMatcherWords
  47. 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
  48. val determined: DeterminedWord

    Definition Classes
    Explicitly
  49. val empty: EmptyWord

    This field enables the following syntax:

    This field enables the following syntax:

    list will be (empty)
                    ^
    

    Definition Classes
    FactMatcherWords
  50. 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
  51. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  52. 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
  53. 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
  54. 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
  55. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  56. def every(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  57. def every[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): 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
  58. def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  59. def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  60. 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]], prettifier: Prettifier, pos: Position): 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
  61. def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  62. val exist: ExistWord

    This field enables the following syntax:

    This field enables the following syntax:

    file will exist
                ^
    

    Definition Classes
    FactMatcherWords
  63. def expect(expression: Boolean)(implicit prettifier: Prettifier, pos: Position): Fact

    Definition Classes
    Expectations
    Annotations
    @macroImpl( ... )
  64. def expectCompiles(code: String)(implicit prettifier: Prettifier, pos: Position): Fact

    Definition Classes
    Expectations
    Annotations
    @macroImpl( ... )
  65. def expectDoesNotCompile(code: String)(implicit prettifier: Prettifier, pos: Position): Fact

    Definition Classes
    Expectations
    Annotations
    @macroImpl( ... )
  66. def expectResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Fact

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

    Definition Classes
    Expectations
  68. def expectTypeError(code: String)(implicit prettifier: Prettifier, pos: Position): Fact

    Definition Classes
    Expectations
    Annotations
    @macroImpl( ... )
  69. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  70. 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
  71. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  72. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  73. 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
  74. def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  75. 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
  76. def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  77. 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
  78. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  79. val key: KeyWord

    This field enables the following syntax:

    This field enables the following syntax:

    map will not contain key (10)
                           ^
    

    Definition Classes
    WillMatchers
  80. val length: LengthWord

    This field enables the following syntax:

    This field enables the following syntax:

    "hi" will not have length (3)
                         ^
    

    Definition Classes
    FactMatcherWords
  81. val matchPattern: MatchPatternWord

    This field enables the following syntax:

    This field enables the following syntax:

    result will matchPattern { case Person("Bob", _) => }
                  ^
    

    Definition Classes
    FactMatcherWords
  82. 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
  83. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  84. def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): 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
  85. def no[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], prettifier: Prettifier, pos: Position): 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
  86. def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): 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
  87. 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
  88. def noException(implicit pos: Position): FactExceptionWord

    This field enables the following syntax:

    This field enables the following syntax:

    noException will be thrownBy
    ^
    

    Definition Classes
    FactMatcherWords
  89. def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  90. 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
  91. final def notify(): Unit

    Definition Classes
    AnyRef
  92. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  93. 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
  94. 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
  95. def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): 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
  96. def only(xs: Any*)(implicit pos: Position): 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
  97. val readable: ReadableWord

    This field enables the following syntax:

    This field enables the following syntax:

    file will be (readable)
                    ^
    

    Definition Classes
    FactMatcherWords
  98. 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
  99. val size: SizeWord

    This field enables the following syntax:

    This field enables the following syntax:

    set will not have size (3)
                        ^
    

    Definition Classes
    FactMatcherWords
  100. val sorted: SortedWord

    This field enables the following syntax:

    This field enables the following syntax:

    seq will be (sorted)
                  ^
    

    Definition Classes
    FactMatcherWords
  101. 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
  102. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  103. def the[T](implicit arg0: ClassTag[T], pos: Position): ResultOfTheTypeInvocation[T]

    This method enables the following syntax:

    This method enables the following syntax:

    the [FileNotFoundException] will be thrownBy { ... }
    ^
    

    Definition Classes
    WillMatchers
  104. 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
  105. 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
  106. val theSameInstanceAs: TheSameInstanceAsPhrase

    This field enables the following syntax:

    This field enables the following syntax:

    oneString will not be theSameInstanceAs (anotherString)
                            ^
    

    Definition Classes
    WillMatchers
  107. 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
  108. def toString(): String

    Definition Classes
    AnyRef → Any
  109. val typeCheck: TypeCheckWord

    This field enables the following syntax:

    This field enables the following syntax:

    "val a: String = 1" willNot typeCheck
                                  ^
    

    Definition Classes
    FactMatcherWords
  110. val value: ValueWord

    This field enables the following syntax:

    This field enables the following syntax:

    map will not contain value (10)
                           ^
    

    Definition Classes
    WillMatchers
  111. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  112. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  113. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  114. val writable: WritableWord

    This field enables the following syntax:

    This field enables the following syntax:

    file will be (writable)
                    ^
    

    Definition Classes
    FactMatcherWords

Inherited from WillMatchers

Inherited from Explicitly

Inherited from FactMatcherWords

Inherited from WillVerb

Inherited from Tolerance

Inherited from Expectations

Inherited from AnyRef

Inherited from Any

Ungrouped