Object/Trait

org.scalatest

MustMatchers

Related Docs: trait MustMatchers | package scalatest

Permalink

object MustMatchers extends MustMatchers

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.

Source
MustMatchers.scala
Linear Supertypes
MustMatchers, Explicitly, MatcherWords, MustVerb, Tolerance, Assertions, TripleEquals, TripleEqualsSupport, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. MustMatchers
  2. MustMatchers
  3. Explicitly
  4. MatcherWords
  5. MustVerb
  6. Tolerance
  7. Assertions
  8. TripleEquals
  9. TripleEqualsSupport
  10. AnyRef
  11. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final class AWord extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  2. final class AnWord extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  3. sealed class AnyMustWrapper[T] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    This class is used in conjunction with an implicit conversion to enable must methods to be invoked on objects of type Any.

    Definition Classes
    MustMatchers
  4. class AssertionsHelper extends AnyRef

    Permalink

    Helper class used by code generated by the assert macro.

    Helper class used by code generated by the assert macro.

    Definition Classes
    Assertions
  5. class CheckingEqualizer[L] extends AnyRef

    Permalink
    Definition Classes
    TripleEqualsSupport
  6. class DecidedByEquality[A] extends Equality[A]

    Permalink
    Definition Classes
    Explicitly
  7. class DecidedWord extends AnyRef

    Permalink
    Definition Classes
    Explicitly
  8. class DeterminedByEquivalence[T] extends Equivalence[T]

    Permalink
    Definition Classes
    Explicitly
  9. class DeterminedWord extends AnyRef

    Permalink
    Definition Classes
    Explicitly
  10. class Equalizer[L] extends AnyRef

    Permalink
    Definition Classes
    TripleEqualsSupport
  11. final class HavePropertyMatcherGenerator extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    This class is used as the result of an implicit conversion from class Symbol, to enable symbols to be used in have ('author ("Dickens")) syntax. The name of the implicit conversion method is convertSymbolToHavePropertyMatcherGenerator.

    Class HavePropertyMatcherGenerator's primary constructor takes a Symbol. The apply method uses reflection to find and access a property that has the name specified by the Symbol passed to the constructor, so it can determine if the property has the expected value passed to apply. If the symbol passed is 'title, for example, the apply method will use reflection to look for a public Java field named "title", a public method named "title", or a public method named "getTitle". If a method, it must take no parameters. If multiple candidates are found, the apply method will select based on the following algorithm:

    FieldMethod"get" MethodResult
       Throws TestFailedException, because no candidates found
      getTitle()Invokes getTitle()
     title() Invokes title()
     title()getTitle()Invokes title() (this can occur when BeanProperty annotation is used)
    title  Accesses field title
    title getTitle()Invokes getTitle()
    titletitle() Invokes title()
    titletitle()getTitle()Invokes title() (this can occur when BeanProperty annotation is used)

    Definition Classes
    MustMatchers
  12. final class KeyWord extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  13. final class PlusOrMinusWrapper[T] extends AnyRef

    Permalink
    Definition Classes
    Tolerance
  14. final class RegexWord extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  15. final class RegexWrapper extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    This class is used in conjunction with an implicit conversion to enable withGroup and withGroups methods to be invoked on Regexs.

    Definition Classes
    MustMatchers
  16. class ResultOfBeWordForAny[T] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  17. sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  18. final class ResultOfBeWordForCollectedArray[T] extends ResultOfBeWordForCollectedAny[Array[T]]

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  19. final class ResultOfCollectedAny[T] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  20. final class ResultOfContainWordForCollectedAny[T] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  21. final class ResultOfEndWithWordForCollectedString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  22. final class ResultOfEndWithWordForString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  23. final class ResultOfFullyMatchWordForCollectedString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  24. final class ResultOfFullyMatchWordForString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  25. final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  26. final class ResultOfHaveWordForExtent[A] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  27. final class ResultOfIncludeWordForCollectedString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  28. final class ResultOfIncludeWordForString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  29. final class ResultOfNotWordForCollectedAny[T] extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  30. final class ResultOfStartWithWordForCollectedString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for InspectorsMatchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  31. final class ResultOfStartWithWordForString extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  32. final class StringMustWrapper extends AnyMustWrapper[String] with StringMustWrapperForVerb

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

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

    Definition Classes
    MustMatchers
  33. trait StringMustWrapperForVerb extends AnyRef

    Permalink

    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 must methods to be invoked on Strings.

    Definition Classes
    MustVerb
  34. class TheAfterWord extends AnyRef

    Permalink
    Definition Classes
    Explicitly
  35. final class TheSameInstanceAsPhrase extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers
  36. final class ValueWord extends AnyRef

    Permalink

    This class is part of the ScalaTest matchers DSL.

    This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

    Definition Classes
    MustMatchers

Value Members

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

    Permalink
    Definition Classes
    AnyRef → Any
  2. def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

    Permalink
    Definition Classes
    TripleEqualsSupport
  3. def !==(right: Null): TripleEqualsInvocation[Null]

    Permalink
    Definition Classes
    TripleEqualsSupport
  4. def !==[T](right: T): TripleEqualsInvocation[T]

    Permalink
    Definition Classes
    TripleEqualsSupport
  5. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  6. def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    num must (not be < (10) and not be > (17))
                       ^
    

    Definition Classes
    MustMatchers
  7. def <=[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanOrEqualToComparison[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    num must (not be <= (10) and not be > (17))
                       ^
    

    Definition Classes
    MustMatchers
  8. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  9. def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

    Permalink
    Definition Classes
    TripleEqualsSupport
  10. def ===(right: Null): TripleEqualsInvocation[Null]

    Permalink
    Definition Classes
    TripleEqualsSupport
  11. def ===[T](right: T): TripleEqualsInvocation[T]

    Permalink
    Definition Classes
    TripleEqualsSupport
  12. def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    num must (not be > (10) and not be < (7))
                       ^
    

    Definition Classes
    MustMatchers
  13. def >=[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanOrEqualToComparison[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    num must (not be >= (10) and not be < (7))
                       ^
    

    Definition Classes
    MustMatchers
  14. def a[T](implicit arg0: ClassTag[T]): ResultOfATypeInvocation[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    a [RuntimeException] must be thrownBy { ... }
    ^
    

    Definition Classes
    MustMatchers
  15. val a: AWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    badBook must not be a ('goodRead)
                          ^
    

    Definition Classes
    MustMatchers
  16. val after: TheAfterWord

    Permalink
    Definition Classes
    Explicitly
  17. def all(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    all(str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  18. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    all(jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  19. def all[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  20. def allElementsOf[R](elements: GenTraversable[R]): ResultOfAllElementsOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (allElementsOf(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  21. def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAllOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (allOf(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  22. def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    an [Exception] must be thrownBy { ... }
    ^
    

    Definition Classes
    MustMatchers
  23. val an: AnWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    badBook must not be an (excellentRead)
                          ^
    

    Definition Classes
    MustMatchers
  24. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  25. macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Permalink

    Assert that a boolean condition, described in String message, is true.

    Assert that a boolean condition, described in String message, is true. If the condition is true, this method returns normally. Else, it throws TestFailedException with a helpful error message appended with the String obtained by invoking toString on the specified clue as the exception's detail message.

    This method is implemented in terms of a Scala macro that will generate a more helpful error message for expressions of this form:

    • assert(a == b, "a good clue")
    • assert(a != b, "a good clue")
    • assert(a === b, "a good clue")
    • assert(a !== b, "a good clue")
    • assert(a > b, "a good clue")
    • assert(a >= b, "a good clue")
    • assert(a < b, "a good clue")
    • assert(a <= b, "a good clue")
    • assert(a startsWith "prefix", "a good clue")
    • assert(a endsWith "postfix", "a good clue")
    • assert(a contains "something", "a good clue")
    • assert(a eq b, "a good clue")
    • assert(a ne b, "a good clue")
    • assert(a > 0 && b > 5, "a good clue")
    • assert(a > 0 || b > 5, "a good clue")
    • assert(a.isEmpty, "a good clue")
    • assert(!a.isEmpty, "a good clue")
    • assert(a.isInstanceOf[String], "a good clue")
    • assert(a.length == 8, "a good clue")
    • assert(a.size == 8, "a good clue")
    • assert(a.exists(_ == 8), "a good clue")

    At this time, any other form of expression will just get a TestFailedException with message saying the given expression was false. In the future, we will enhance this macro to give helpful error messages in more situations. In ScalaTest 2.0, however, this behavior was sufficient to allow the === that returns Boolean to be the default in tests. This makes === consistent between tests and production code.

    condition

    the boolean condition to assert

    clue

    An objects whose toString method returns a message to include in a failure report.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if message is null.

    TestFailedException if the condition is false.

  26. macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

    Permalink

    Assert that a boolean condition is true.

    Assert that a boolean condition is true. If the condition is true, this method returns normally. Else, it throws TestFailedException.

    This method is implemented in terms of a Scala macro that will generate a more helpful error message for expressions of this form:

    • assert(a == b)
    • assert(a != b)
    • assert(a === b)
    • assert(a !== b)
    • assert(a > b)
    • assert(a >= b)
    • assert(a < b)
    • assert(a <= b)
    • assert(a startsWith "prefix")
    • assert(a endsWith "postfix")
    • assert(a contains "something")
    • assert(a eq b)
    • assert(a ne b)
    • assert(a > 0 && b > 5)
    • assert(a > 0 || b > 5)
    • assert(a.isEmpty)
    • assert(!a.isEmpty)
    • assert(a.isInstanceOf[String])
    • assert(a.length == 8)
    • assert(a.size == 8)
    • assert(a.exists(_ == 8))

    At this time, any other form of expression will get a TestFailedException with message saying the given expression was false. In the future, we will enhance this macro to give helpful error messages in more situations. In ScalaTest 2.0, however, this behavior was sufficient to allow the === that returns Boolean to be the default in tests. This makes === consistent between tests and production code.

    condition

    the boolean condition to assert

    Definition Classes
    Assertions
    Exceptions thrown

    TestFailedException if the condition is false.

  27. macro def assertCompiles(code: String)(implicit pos: Position): Assertion

    Permalink

    Asserts that a given string snippet of code passes both the Scala parser and type checker.

    Asserts that a given string snippet of code passes both the Scala parser and type checker.

    You can use this to make sure a snippet of code compiles:

    assertCompiles("val a: Int = 1")
    

    Although assertCompiles is implemented with a macro that determines at compile time whether the snippet of code represented by the passed string compiles, errors (i.e., snippets of code that do not compile) are reported as test failures at runtime.

    code

    the snippet of code that should compile

    Definition Classes
    Assertions
  28. macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

    Permalink

    Asserts that a given string snippet of code does not pass either the Scala parser or type checker.

    Asserts that a given string snippet of code does not pass either the Scala parser or type checker.

    Often when creating libraries you may wish to ensure that certain arrangements of code that represent potential “user errors” do not compile, so that your library is more error resistant. ScalaTest's Assertions trait includes the following syntax for that purpose:

    assertDoesNotCompile("val a: String = \"a string")
    

    Although assertDoesNotCompile is implemented with a macro that determines at compile time whether the snippet of code represented by the passed string doesn't compile, errors (i.e., snippets of code that do compile) are reported as test failures at runtime.

    Note that the difference between assertTypeError and assertDoesNotCompile is that assertDoesNotCompile will succeed if the given code does not compile for any reason, whereas assertTypeError will only succeed if the given code does not compile because of a type error. If the given code does not compile because of a syntax error, for example, assertDoesNotCompile will return normally but assertTypeError will throw a TestFailedException.

    code

    the snippet of code that should not type check

    Definition Classes
    Assertions
  29. def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Permalink

    Assert that the value passed as expected equals the value passed as actual.

    Assert that the value passed as expected equals the value passed as actual. If the actual value equals the expected value (as determined by ==), assertResult returns normally. Else, assertResult throws a TestFailedException whose detail message includes the expected and actual values.

    expected

    the expected value

    actual

    the actual value, which should equal the passed expected value

    Definition Classes
    Assertions
    Exceptions thrown

    TestFailedException if the passed actual value does not equal the passed expected value.

  30. def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Permalink

    Assert that the value passed as expected equals the value passed as actual.

    Assert that the value passed as expected equals the value passed as actual. If the actual equals the expected (as determined by ==), assertResult returns normally. Else, if actual is not equal to expected, assertResult throws a TestFailedException whose detail message includes the expected and actual values, as well as the String obtained by invoking toString on the passed clue.

    expected

    the expected value

    clue

    An object whose toString method returns a message to include in a failure report.

    actual

    the actual value, which should equal the passed expected value

    Definition Classes
    Assertions
    Exceptions thrown

    TestFailedException if the passed actual value does not equal the passed expected value.

  31. def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

    Permalink

    Ensure that an expected exception is thrown by the passed function value.

    Ensure that an expected exception is thrown by the passed function value. The thrown exception must be an instance of the type specified by the type parameter of this method. This method invokes the passed function. If the function throws an exception that's an instance of the specified type, this method returns Succeeded. Else, whether the passed function returns normally or completes abruptly with a different exception, this method throws TestFailedException.

    Note that the type specified as this method's type parameter may represent any subtype of AnyRef, not just Throwable or one of its subclasses. In Scala, exceptions can be caught based on traits they implement, so it may at times make sense to specify a trait that the intercepted exception's class must mix in. If a class instance is passed for a type that could not possibly be used to catch an exception (such as String, for example), this method will complete abruptly with a TestFailedException.

    Also note that the difference between this method and intercept is that this method does not return the expected exception, so it does not let you perform further assertions on that exception. Instead, this method returns Succeeded, which means it can serve as the last statement in an async- or safe-style suite. It also indicates to the reader of the code that nothing further is expected about the thrown exception other than its type. The recommended usage is to use assertThrows by default, intercept only when you need to inspect the caught exception further.

    f

    the function value that should throw the expected exception

    classTag

    an implicit ClassTag representing the type of the specified type parameter.

    returns

    the Succeeded singleton, if an exception of the expected type is thrown

    Definition Classes
    Assertions
    Exceptions thrown

    TestFailedException if the passed function does not complete abruptly with an exception that's an instance of the specified type.

  32. macro def assertTypeError(code: String)(implicit pos: Position): Assertion

    Permalink

    Asserts that a given string snippet of code does not pass the Scala type checker, failing if the given snippet does not pass the Scala parser.

    Asserts that a given string snippet of code does not pass the Scala type checker, failing if the given snippet does not pass the Scala parser.

    Often when creating libraries you may wish to ensure that certain arrangements of code that represent potential “user errors” do not compile, so that your library is more error resistant. ScalaTest's Assertions trait includes the following syntax for that purpose:

    assertTypeError("val a: String = 1")
    

    Although assertTypeError is implemented with a macro that determines at compile time whether the snippet of code represented by the passed string type checks, errors (i.e., snippets of code that do type check) are reported as test failures at runtime.

    Note that the difference between assertTypeError and assertDoesNotCompile is that assertDoesNotCompile will succeed if the given code does not compile for any reason, whereas assertTypeError will only succeed if the given code does not compile because of a type error. If the given code does not compile because of a syntax error, for example, assertDoesNotCompile will return normally but assertTypeError will throw a TestFailedException.

    code

    the snippet of code that should not type check

    Definition Classes
    Assertions
  33. val assertionsHelper: AssertionsHelper

    Permalink

    Helper instance used by code generated by macro assertion.

    Helper instance used by code generated by macro assertion.

    Definition Classes
    Assertions
  34. macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    Permalink

    Assume that a boolean condition, described in String message, is true.

    Assume that a boolean condition, described in String message, is true. If the condition is true, this method returns normally. Else, it throws TestCanceledException with a helpful error message appended with String obtained by invoking toString on the specified clue as the exception's detail message.

    This method is implemented in terms of a Scala macro that will generate a more helpful error message for expressions of this form:

    • assume(a == b, "a good clue")
    • assume(a != b, "a good clue")
    • assume(a === b, "a good clue")
    • assume(a !== b, "a good clue")
    • assume(a > b, "a good clue")
    • assume(a >= b, "a good clue")
    • assume(a < b, "a good clue")
    • assume(a <= b, "a good clue")
    • assume(a startsWith "prefix", "a good clue")
    • assume(a endsWith "postfix", "a good clue")
    • assume(a contains "something", "a good clue")
    • assume(a eq b, "a good clue")
    • assume(a ne b, "a good clue")
    • assume(a > 0 && b > 5, "a good clue")
    • assume(a > 0 || b > 5, "a good clue")
    • assume(a.isEmpty, "a good clue")
    • assume(!a.isEmpty, "a good clue")
    • assume(a.isInstanceOf[String], "a good clue")
    • assume(a.length == 8, "a good clue")
    • assume(a.size == 8, "a good clue")
    • assume(a.exists(_ == 8), "a good clue")

    At this time, any other form of expression will just get a TestCanceledException with message saying the given expression was false. In the future, we will enhance this macro to give helpful error messages in more situations. In ScalaTest 2.0, however, this behavior was sufficient to allow the === that returns Boolean to be the default in tests. This makes === consistent between tests and production code.

    condition

    the boolean condition to assume

    clue

    An objects whose toString method returns a message to include in a failure report.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if message is null.

    TestCanceledException if the condition is false.

  35. macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

    Permalink

    Assume that a boolean condition is true.

    Assume that a boolean condition is true. If the condition is true, this method returns normally. Else, it throws TestCanceledException.

    This method is implemented in terms of a Scala macro that will generate a more helpful error message for expressions of this form:

    • assume(a == b)
    • assume(a != b)
    • assume(a === b)
    • assume(a !== b)
    • assume(a > b)
    • assume(a >= b)
    • assume(a < b)
    • assume(a <= b)
    • assume(a startsWith "prefix")
    • assume(a endsWith "postfix")
    • assume(a contains "something")
    • assume(a eq b)
    • assume(a ne b)
    • assume(a > 0 && b > 5)
    • assume(a > 0 || b > 5)
    • assume(a.isEmpty)
    • assume(!a.isEmpty)
    • assume(a.isInstanceOf[String])
    • assume(a.length == 8)
    • assume(a.size == 8)
    • assume(a.exists(_ == 8))

    At this time, any other form of expression will just get a TestCanceledException with message saying the given expression was false. In the future, we will enhance this macro to give helpful error messages in more situations. In ScalaTest 2.0, however, this behavior was sufficient to allow the === that returns Boolean to be the default in tests. This makes === consistent between tests and production code.

    condition

    the boolean condition to assume

    Definition Classes
    Assertions
    Exceptions thrown

    TestCanceledException if the condition is false.

  36. def atLeast(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    atLeast(1, str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  37. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    atLeast(1, jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  38. def atLeast[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    atLeast(1, xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  39. def atLeastOneElementOf(elements: GenTraversable[Any]): ResultOfAtLeastOneElementOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (atLeastOneElementOf (List(1, 2)))
                                  ^
    

    Definition Classes
    MustMatchers
  40. def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtLeastOneOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (atLeastOneOf(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  41. def atMost(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    atMost(3, str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  42. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    atMost(3, jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  43. def atMost[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    atMost(3, xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  44. def atMostOneElementOf[R](elements: GenTraversable[R]): ResultOfAtMostOneElementOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (atMostOneElementOf (List(1, 2)))
                                  ^
    

    Definition Classes
    MustMatchers
  45. def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfAtMostOneOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (atMostOneOf(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  46. val be: BeWord

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    obj should (be theSameInstanceAs (string) and be theSameInstanceAs (string))
                ^
    

    Definition Classes
    MatcherWords
  47. def between(from: Int, upTo: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    between(1, 3, str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  48. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    between(1, 3, jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  49. def between[E, C[_]](from: Int, upTo: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    between(1, 3, xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  50. def cancel(cause: Throwable)(implicit pos: Position): Nothing

    Permalink

    Throws TestCanceledException, with the passed Throwable cause, to indicate a test failed.

    Throws TestCanceledException, with the passed Throwable cause, to indicate a test failed. The getMessage method of the thrown TestCanceledException will return cause.toString.

    cause

    a Throwable that indicates the cause of the cancellation.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if cause is null

  51. def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

    Permalink

    Throws TestCanceledException, with the passed String message as the exception's detail message and Throwable cause, to indicate a test failed.

    Throws TestCanceledException, with the passed String message as the exception's detail message and Throwable cause, to indicate a test failed.

    message

    A message describing the failure.

    cause

    A Throwable that indicates the cause of the failure.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if message or cause is null

  52. def cancel(message: String)(implicit pos: Position): Nothing

    Permalink

    Throws TestCanceledException, with the passed String message as the exception's detail message, to indicate a test was canceled.

    Throws TestCanceledException, with the passed String message as the exception's detail message, to indicate a test was canceled.

    message

    A message describing the cancellation.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if message is null

  53. def cancel()(implicit pos: Position): Nothing

    Permalink

    Throws TestCanceledException to indicate a test was canceled.

    Throws TestCanceledException to indicate a test was canceled.

    Definition Classes
    Assertions
  54. def clone(): AnyRef

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

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    "val a: String = 1" shouldNot compile
                                  ^
    

    Definition Classes
    MatcherWords
  56. val contain: ContainWord

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    list should (contain ('a') and have length (7))
                 ^
    

    Definition Classes
    MatcherWords
  57. def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  58. def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  59. def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  60. def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  61. def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  62. implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]

    Permalink
    Definition Classes
    Tolerance
  63. implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): HavePropertyMatcherGenerator

    Permalink

    This implicit conversion method converts a Symbol to a HavePropertyMatcherGenerator, to enable the symbol to be used with the have ('author ("Dickens")) syntax.

    This implicit conversion method converts a Symbol to a HavePropertyMatcherGenerator, to enable the symbol to be used with the have ('author ("Dickens")) syntax.

    Definition Classes
    MustMatchers
  64. implicit def convertToAnyMustWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyMustWrapper[T]

    Permalink

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

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

    Definition Classes
    MustMatchers
  65. def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  66. implicit def convertToEqualizer[T](left: T): Equalizer[T]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  67. implicit def convertToRegexWrapper(o: Regex): RegexWrapper

    Permalink

    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
    MustMatchers
  68. implicit def convertToStringMustWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringMustWrapper

    Permalink

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

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

    Definition Classes
    MustMatchers
  69. implicit def convertToStringMustWrapperForVerb(o: String)(implicit position: Position): StringMustWrapperForVerb

    Permalink

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

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

    Definition Classes
    MustVerb
  70. val decided: DecidedWord

    Permalink
    Definition Classes
    Explicitly
  71. def defaultEquality[A]: Equality[A]

    Permalink
    Definition Classes
    TripleEqualsSupport
  72. val defined: DefinedWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    seq should be (defined)
                  ^
    

    Definition Classes
    MatcherWords
  73. def definedAt[T](right: T): ResultOfDefinedAt[T]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    list must (not be definedAt (7) and not be definedAt (9))
                        ^
    

    Definition Classes
    MustMatchers
  74. val determined: DeterminedWord

    Permalink
    Definition Classes
    Explicitly
  75. val empty: EmptyWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    list should be (empty)
                    ^
    

    Definition Classes
    MatcherWords
  76. val endWith: EndWithWord

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    string should (endWith ("ago") and include ("score"))
                   ^
    

    Definition Classes
    MatcherWords
  77. final def eq(arg0: AnyRef): Boolean

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

    Permalink

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    result must equal (null)
                  ^
    

    Definition Classes
    MustMatchers
  79. def equal[T](spread: Spread[T]): Matcher[T]

    Permalink

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    result must equal (100 +- 1)
                  ^
    

    Definition Classes
    MustMatchers
  80. def equal(right: Any): MatcherFactory1[Any, Equality]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    result should equal (7)
                  ^
    

    The left should 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) should 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
    MatcherWords
  81. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  82. def every(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    every(str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  83. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    every(jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  84. def every[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    every(xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  85. def exactly(num: Int, xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    exactly(str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  86. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    exactly(jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  87. def exactly[E, C[_]](num: Int, xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    exactly(xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  88. val exist: ExistWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    file should exist
                ^
    

    Definition Classes
    MatcherWords
  89. def fail(cause: Throwable)(implicit pos: Position): Nothing

    Permalink

    Throws TestFailedException, with the passed Throwable cause, to indicate a test failed.

    Throws TestFailedException, with the passed Throwable cause, to indicate a test failed. The getMessage method of the thrown TestFailedException will return cause.toString.

    cause

    a Throwable that indicates the cause of the failure.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if cause is null

  90. def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

    Permalink

    Throws TestFailedException, with the passed String message as the exception's detail message and Throwable cause, to indicate a test failed.

    Throws TestFailedException, with the passed String message as the exception's detail message and Throwable cause, to indicate a test failed.

    message

    A message describing the failure.

    cause

    A Throwable that indicates the cause of the failure.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if message or cause is null

  91. def fail(message: String)(implicit pos: Position): Nothing

    Permalink

    Throws TestFailedException, with the passed String message as the exception's detail message, to indicate a test failed.

    Throws TestFailedException, with the passed String message as the exception's detail message, to indicate a test failed.

    message

    A message describing the failure.

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if message is null

  92. def fail()(implicit pos: Position): Nothing

    Permalink

    Throws TestFailedException to indicate a test failed.

    Throws TestFailedException to indicate a test failed.

    Definition Classes
    Assertions
  93. def finalize(): Unit

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

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    string should (fullyMatch regex ("Hel*o, wor.d") and not have length (99))
                   ^
    

    Definition Classes
    MatcherWords
  95. final def getClass(): Class[_]

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

    Permalink
    Definition Classes
    AnyRef → Any
  97. val have: HaveWord

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    list should (have length (3) and not contain ('a'))
                 ^
    

    Definition Classes
    MatcherWords
  98. def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (inOrder(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  99. def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (inOrderElementsOf List(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  100. def inOrderOnly[T](firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfInOrderOnlyApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (inOrderOnly(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  101. val include: IncludeWord

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    string should (include ("hope") and not startWith ("no"))
                   ^
    

    Definition Classes
    MatcherWords
  102. def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): T

    Permalink

    Intercept and return an exception that's expected to be thrown by the passed function value.

    Intercept and return an exception that's expected to be thrown by the passed function value. The thrown exception must be an instance of the type specified by the type parameter of this method. This method invokes the passed function. If the function throws an exception that's an instance of the specified type, this method returns that exception. Else, whether the passed function returns normally or completes abruptly with a different exception, this method throws TestFailedException.

    Note that the type specified as this method's type parameter may represent any subtype of AnyRef, not just Throwable or one of its subclasses. In Scala, exceptions can be caught based on traits they implement, so it may at times make sense to specify a trait that the intercepted exception's class must mix in. If a class instance is passed for a type that could not possibly be used to catch an exception (such as String, for example), this method will complete abruptly with a TestFailedException.

    Also note that the difference between this method and assertThrows is that this method returns the expected exception, so it lets you perform further assertions on that exception. By contrast, the assertThrows method returns Succeeded, which means it can serve as the last statement in an async- or safe-style suite. assertThrows also indicates to the reader of the code that nothing further is expected about the thrown exception other than its type. The recommended usage is to use assertThrows by default, intercept only when you need to inspect the caught exception further.

    f

    the function value that should throw the expected exception

    classTag

    an implicit ClassTag representing the type of the specified type parameter.

    returns

    the intercepted exception, if it is of the expected type

    Definition Classes
    Assertions
    Exceptions thrown

    TestFailedException if the passed function does not complete abruptly with an exception that's an instance of the specified type.

  103. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  104. val key: KeyWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    map must not contain key (10)
                           ^
    

    Definition Classes
    MustMatchers
  105. val length: LengthWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    "hi" should not have length (3)
                         ^
    

    Definition Classes
    MatcherWords
  106. def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  107. def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  108. val matchPattern: MatchPatternWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

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

    Definition Classes
    MatcherWords
  109. def message(expectedMessage: String): ResultOfMessageWordApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    exception must not have message ("file not found")
                              ^
    

    Definition Classes
    MustMatchers
  110. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  111. def no(xs: String)(implicit collecting: Collecting[Char, String], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[Char]

    Permalink

    This method enables the following syntax for String:

    This method enables the following syntax for String:

    no(str) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  112. 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]]

    Permalink

    This method enables the following syntax for java.util.Map:

    This method enables the following syntax for java.util.Map:

    no(jmap) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  113. def no[E, C[_]](xs: C[E])(implicit collecting: Collecting[E, C[E]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[E]

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    no(xs) must fullymatch regex ("Hel*o world".r)
    ^
    

    Definition Classes
    MustMatchers
  114. def noElementsOf(elements: GenTraversable[Any]): ResultOfNoElementsOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (noElementsOf List(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  115. def noException(implicit pos: Position): NoExceptionWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    noException should be thrownBy
    ^
    

    Definition Classes
    MatcherWords
  116. def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfNoneOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (noneOf(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  117. val not: NotWord

    Permalink

    This field enables syntax like the following:

    This field enables syntax like the following:

    myFile should (not be an (directory) and not have ('name ("foo.bar")))
                   ^
    

    Definition Classes
    MatcherWords
  118. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  119. final def notifyAll(): Unit

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

    Permalink

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    book must have (message ("A TALE OF TWO CITIES") (of [Book]), title ("A Tale of Two Cities"))
                                                        ^
    

    Definition Classes
    MustMatchers
  121. def oneElementOf(elements: GenTraversable[Any]): ResultOfOneElementOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (oneElementOf (List(1, 2)))
                                  ^
    

    Definition Classes
    MustMatchers
  122. def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit pos: Position): ResultOfOneOfApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (oneOf(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  123. def only(xs: Any*)(implicit pos: Position): ResultOfOnlyApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (only(1, 2))
                                  ^
    

    Definition Classes
    MustMatchers
  124. def pending: Assertion with PendingStatement

    Permalink

    Throws TestPendingException to indicate a test is pending.

    Throws TestPendingException to indicate a test is pending.

    A pending test is one that has been given a name but is not yet implemented. The purpose of pending tests is to facilitate a style of testing in which documentation of behavior is sketched out before tests are written to verify that behavior (and often, the before the behavior of the system being tested is itself implemented). Such sketches form a kind of specification of what tests and functionality to implement later.

    To support this style of testing, a test can be given a name that specifies one bit of behavior required by the system being tested. The test can also include some code that sends more information about the behavior to the reporter when the tests run. At the end of the test, it can call method pending, which will cause it to complete abruptly with TestPendingException. Because tests in ScalaTest can be designated as pending with TestPendingException, both the test name and any information sent to the reporter when running the test can appear in the report of a test run. (In other words, the code of a pending test is executed just like any other test.) However, because the test completes abruptly with TestPendingException, the test will be reported as pending, to indicate the actual test, and possibly the functionality it is intended to test, has not yet been implemented.

    Note: This method always completes abruptly with a TestPendingException. Thus it always has a side effect. Methods with side effects are usually invoked with parentheses, as in pending(). This method is defined as a parameterless method, in flagrant contradiction to recommended Scala style, because it forms a kind of DSL for pending tests. It enables tests in suites such as FunSuite or FunSpec to be denoted by placing "(pending)" after the test name, as in:

    test("that style rules are not laws") (pending)
    

    Readers of the code see "pending" in parentheses, which looks like a little note attached to the test name to indicate it is pending. Whereas "(pending()) looks more like a method call, "(pending)" lets readers stay at a higher level, forgetting how it is implemented and just focusing on the intent of the programmer who wrote the code.

    Definition Classes
    Assertions
  125. def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

    Permalink

    Execute the passed block of code, and if it completes abruptly, throw TestPendingException, else throw TestFailedException.

    Execute the passed block of code, and if it completes abruptly, throw TestPendingException, else throw TestFailedException.

    This method can be used to temporarily change a failing test into a pending test in such a way that it will automatically turn back into a failing test once the problem originally causing the test to fail has been fixed. At that point, you need only remove the pendingUntilFixed call. In other words, a pendingUntilFixed surrounding a block of code that isn't broken is treated as a test failure. The motivation for this behavior is to encourage people to remove pendingUntilFixed calls when there are no longer needed.

    This method facilitates a style of testing in which tests are written before the code they test. Sometimes you may encounter a test failure that requires more functionality than you want to tackle without writing more tests. In this case you can mark the bit of test code causing the failure with pendingUntilFixed. You can then write more tests and functionality that eventually will get your production code to a point where the original test won't fail anymore. At this point the code block marked with pendingUntilFixed will no longer throw an exception (because the problem has been fixed). This will in turn cause pendingUntilFixed to throw TestFailedException with a detail message explaining you need to go back and remove the pendingUntilFixed call as the problem orginally causing your test code to fail has been fixed.

    f

    a block of code, which if it completes abruptly, should trigger a TestPendingException

    Definition Classes
    Assertions
    Exceptions thrown

    TestPendingException if the passed block of code completes abruptly with an Exception or AssertionError

  126. val readable: ReadableWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    file should be (readable)
                    ^
    

    Definition Classes
    MatcherWords
  127. val regex: RegexWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    "eight" must not fullyMatch regex ("""(-)?(\d+)(\.\d*)?""".r)
                                  ^
    

    Definition Classes
    MustMatchers
  128. val size: SizeWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    set should not have size (3)
                        ^
    

    Definition Classes
    MatcherWords
  129. val sorted: SortedWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    seq should be (sorted)
                  ^
    

    Definition Classes
    MatcherWords
  130. val startWith: StartWithWord

    Permalink

    This field enables syntax such as the following:

    This field enables syntax such as the following:

    string should (startWith ("Four") and include ("year"))
                   ^
    

    Definition Classes
    MatcherWords
  131. final val succeed: Assertion

    Permalink

    The Succeeded singleton.

    The Succeeded singleton.

    You can use succeed to solve a type error when an async test does not end in either Future[Assertion] or Assertion. Because Assertion is a type alias for Succeeded.type, putting succeed at the end of a test body (or at the end of a function being used to map the final future of a test body) will solve the type error.

    Definition Classes
    Assertions
  132. final def synchronized[T0](arg0: ⇒ T0): T0

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

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

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

    Definition Classes
    MustMatchers
  134. def theSameElementsAs(xs: GenTraversable[_]): ResultOfTheSameElementsAsApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (theSameElementsAs(List(1, 2, 3)))
                                  ^
    

    Definition Classes
    MustMatchers
  135. def theSameElementsInOrderAs(xs: GenTraversable[_]): ResultOfTheSameElementsInOrderAsApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    List(1, 2, 3) must contain (theSameElementsInOrderAs(List(1, 2)))
                                  ^
    

    Definition Classes
    MustMatchers
  136. val theSameInstanceAs: TheSameInstanceAsPhrase

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    oneString must not be theSameInstanceAs (anotherString)
                            ^
    

    Definition Classes
    MustMatchers
  137. def thrownBy(fun: ⇒ Any): ResultOfThrownByApplication

    Permalink

    This method enables the following syntax:

    This method enables the following syntax:

    a [RuntimeException] must be thrownBy {...}
                                   ^
    

    Definition Classes
    MustMatchers
  138. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  139. val typeCheck: TypeCheckWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    "val a: String = 1" shouldNot typeCheck
                                  ^
    

    Definition Classes
    MatcherWords
  140. def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  141. implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

    Permalink
    Definition Classes
    TripleEquals → TripleEqualsSupport
  142. val value: ValueWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    map must not contain value (10)
                           ^
    

    Definition Classes
    MustMatchers
  143. final def wait(): Unit

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

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

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  146. def withClue[T](clue: Any)(fun: ⇒ T): T

    Permalink

    Executes the block of code passed as the second parameter, and, if it completes abruptly with a ModifiableMessage exception, prepends the "clue" string passed as the first parameter to the beginning of the detail message of that thrown exception, then rethrows it.

    Executes the block of code passed as the second parameter, and, if it completes abruptly with a ModifiableMessage exception, prepends the "clue" string passed as the first parameter to the beginning of the detail message of that thrown exception, then rethrows it. If clue does not end in a white space character, one space will be added between it and the existing detail message (unless the detail message is not defined).

    This method allows you to add more information about what went wrong that will be reported when a test fails. Here's an example:

    withClue("(Employee's name was: " + employee.name + ")") {
      intercept[IllegalArgumentException] {
        employee.getTask(-1)
      }
    }
    

    If an invocation of intercept completed abruptly with an exception, the resulting message would be something like:

    (Employee's name was Bob Jones) Expected IllegalArgumentException to be thrown, but no exception was thrown
    

    Definition Classes
    Assertions
    Exceptions thrown

    NullArgumentException if the passed clue is null

  147. val writable: WritableWord

    Permalink

    This field enables the following syntax:

    This field enables the following syntax:

    file should be (writable)
                    ^
    

    Definition Classes
    MatcherWords

Deprecated Value Members

  1. def trap[T](f: ⇒ T): Throwable

    Permalink

    Trap and return any thrown exception that would normally cause a ScalaTest test to fail, or create and return a new RuntimeException indicating no exception is thrown.

    Trap and return any thrown exception that would normally cause a ScalaTest test to fail, or create and return a new RuntimeException indicating no exception is thrown.

    This method is intended to be used in the Scala interpreter to eliminate large stack traces when trying out ScalaTest assertions and matcher expressions. It is not intended to be used in regular test code. If you want to ensure that a bit of code throws an expected exception, use intercept, not trap. Here's an example interpreter session without trap:

    scala> import org.scalatest._
    import org.scalatest._
    
    scala> import Matchers._
    import Matchers._
    
    scala> val x = 12
    a: Int = 12
    
    scala> x shouldEqual 13
    org.scalatest.exceptions.TestFailedException: 12 did not equal 13
       at org.scalatest.Assertions$class.newAssertionFailedException(Assertions.scala:449)
       at org.scalatest.Assertions$.newAssertionFailedException(Assertions.scala:1203)
       at org.scalatest.Assertions$AssertionsHelper.macroAssertTrue(Assertions.scala:417)
       at .<init>(<console>:15)
       at .<clinit>(<console>)
       at .<init>(<console>:7)
       at .<clinit>(<console>)
       at $print(<console>)
       at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
       at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
       at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
       at java.lang.reflect.Method.invoke(Method.java:597)
       at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:731)
       at scala.tools.nsc.interpreter.IMain$Request.loadAndRun(IMain.scala:980)
       at scala.tools.nsc.interpreter.IMain.loadAndRunReq$1(IMain.scala:570)
       at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:601)
       at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:565)
       at scala.tools.nsc.interpreter.ILoop.reallyInterpret$1(ILoop.scala:745)
       at scala.tools.nsc.interpreter.ILoop.interpretStartingWith(ILoop.scala:790)
       at scala.tools.nsc.interpreter.ILoop.command(ILoop.scala:702)
       at scala.tools.nsc.interpreter.ILoop.processLine$1(ILoop.scala:566)
       at scala.tools.nsc.interpreter.ILoop.innerLoop$1(ILoop.scala:573)
       at scala.tools.nsc.interpreter.ILoop.loop(ILoop.scala:576)
       at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply$mcZ$sp(ILoop.scala:867)
       at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:822)
       at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:822)
       at scala.tools.nsc.util.ScalaClassLoader$.savingContextLoader(ScalaClassLoader.scala:135)
       at scala.tools.nsc.interpreter.ILoop.process(ILoop.scala:822)
       at scala.tools.nsc.MainGenericRunner.runTarget$1(MainGenericRunner.scala:83)
       at scala.tools.nsc.MainGenericRunner.process(MainGenericRunner.scala:96)
       at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:105)
       at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)
    

    That's a pretty tall stack trace. Here's what it looks like when you use trap:

    scala> trap { x shouldEqual 13 }
    res1: Throwable = org.scalatest.exceptions.TestFailedException: 12 did not equal 13
    

    Much less clutter. Bear in mind, however, that if no exception is thrown by the passed block of code, the trap method will create a new NormalResult (a subclass of Throwable made for this purpose only) and return that. If the result was the Unit value, it will simply say that no exception was thrown:

    scala> trap { x shouldEqual 12 }
    res2: Throwable = No exception was thrown.
    

    If the passed block of code results in a value other than Unit, the NormalResult's toString will print the value:

    scala> trap { "Dude!" }
    res3: Throwable = No exception was thrown. Instead, result was: "Dude!"
    

    Although you can access the result value from the NormalResult, its type is Any and therefore not very convenient to use. It is not intended that trap be used in test code. The sole intended use case for trap is decluttering Scala interpreter sessions by eliminating stack traces when executing assertion and matcher expressions.

    Definition Classes
    Assertions
    Annotations
    @deprecated
    Deprecated

    The trap method is no longer needed for demos in the REPL, which now abreviates stack traces, and will be removed in a future version of ScalaTest

Inherited from MustMatchers

Inherited from Explicitly

Inherited from MatcherWords

Inherited from MustVerb

Inherited from Tolerance

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped