Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package scalatest

    ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

    ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

    Definition Classes
    org
  • package matchers

    Classes and traits for matchers.

    Classes and traits for matchers.

    This package is released as part of the scalatest-matchers-core module.

    Definition Classes
    scalatest
  • package should

    Trait and object for ScalaTest Matchers DSL using should.

    Trait and object for ScalaTest Matchers DSL using should.

    This package is released as part of the scalatest-shouldmatchers module.

    Definition Classes
    matchers
  • Matchers

trait Matchers extends Assertions with Tolerance with ShouldVerb with MatcherWords with Explicitly

Trait that provides a domain specific language (DSL) for expressing assertions in tests using the word should.

For example, if you mix Matchers into a suite class, you can write an equality assertion in that suite like this:

result should equal (3)

Here result is a variable, and can be of any type. If the object is an Int with the value 3, execution will continue (i.e., the expression will result in the unit value, ()). Otherwise, a TestFailedException will be thrown with a detail message that explains the problem, such as "7 did not equal 3". This TestFailedException will cause the test to fail.

Here is a table of contents for this documentation:

Trait must.Matchers is an alternative to should.Matchers that provides the exact same meaning, syntax, and behavior as should. The two traits differ only in the English semantics of the verb: should is informal, making the code feel like conversation between the writer and the reader; must is more formal, making the code feel more like a written specification.

Checking equality with matchers

ScalaTest matchers provides five different ways to check equality, each designed to address a different need. They are:

result should equal (3) // can customize equality
result should === (3)   // can customize equality and enforce type constraints
result should be (3)    // cannot customize equality, so fastest to compile
result shouldEqual 3    // can customize equality, no parentheses required
result shouldBe 3       // cannot customize equality, so fastest to compile, no parentheses required

The “left should equal (right)” syntax requires an org.scalactic.Equality[L] to be provided (either implicitly or explicitly), where L is the left-hand type on which should is invoked. In the "left should equal (right)" case, for example, L is the type of left. Thus if left is type Int, the "left should equal (right)" statement would require an Equality[Int].

By default, an implicit Equality[T] instance is available for any type T, in which equality is implemented by simply invoking == on the left value, passing in the right value, with special treatment for arrays. If either left or right is an array, deep will be invoked on it before comparing with ==. Thus, the following expression will yield false, because Array's equals method compares object identity:

Array(1, 2) == Array(1, 2) // yields false

The next expression will by default not result in a TestFailedException, because default Equality[Array[Int]] compares 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, described below.

You can customize the meaning of equality for a type when using "should equal," "should ===," or shouldEqual syntax by defining implicit Equality instances that will be used instead of default Equality. You might do this to normalize types before comparing them with ==, for instance, or to avoid calling the == method entirely, such as if you want to compare Doubles with a tolerance. For an example, see the main documentation of trait org.scalactic.Equality.

You can always supply implicit parameters explicitly, but in the case of implicit parameters of type Equality[T], Scalactic provides a simple "explictly" DSL. For example, here's how you could explicitly supply an Equality[String] instance that normalizes both left and right sides (which must be strings), by transforming them to lowercase:

scala> import org.scalatest.matchers.should.Matchers._
import org.scalatest.matchers.should.Matchers._

scala> import org.scalactic.Explicitly._
import org.scalactic.Explicitly._

scala> import org.scalactic.StringNormalizations._
import org.scalactic.StringNormalizations._

scala> "Hi" should equal ("hi") (after being lowerCased)

The after being lowerCased expression results in an Equality[String], which is then passed explicitly as the second curried parameter to equal. For more information on the explictly DSL, see the main documentation for trait org.scalactic.Explicitly.

The "should be" and shouldBe syntax do not take an Equality[T] and can therefore not be customized. They always use the default approach to equality described above. As a result, "should be" and shouldBe will likely be the fastest-compiling matcher syntax for equality comparisons, since the compiler need not search for an implicit Equality[T] each time.

The should === syntax (and its complement, should !==) can be used to enforce type constraints at compile-time between the left and right sides of the equality comparison. Here's an example:

scala> import org.scalatest.matchers.should.Matchers._
import org.scalatest.matchers.should.Matchers._

scala> import org.scalactic.TypeCheckedTripleEquals._
import org.scalactic.TypeCheckedTripleEquals._

scala> Some(2) should === (2)
<console>:17: error: types Some[Int] and Int do not adhere to the equality constraint
selected for the === and !== operators; the missing implicit parameter is of
type org.scalactic.CanEqual[Some[Int],Int]
              Some(2) should === (2)
                      ^

By default, the "Some(2) should === (2)" statement would fail at runtime. By mixing in the equality constraints provided by TypeCheckedTripleEquals, however, the statement fails to compile. For more information and examples, see the main documentation for trait org.scalactic.TypeCheckedTripleEquals.

Checking size and length

You can check the size or length of any type of object for which it makes sense. Here's how checking for length looks:

result should have length 3

Size is similar:

result should have size 10

The length syntax can be used with String, Array, any scala.collection.GenSeq, any java.util.List, and any type T for which an implicit Length[T] type class is available in scope. Similarly, the size syntax can be used with Array, any scala.collection.GenTraversable, any java.util.Collection, any java.util.Map, and any type T for which an implicit Size[T] type class is available in scope. You can enable the length or size syntax for your own arbitrary types, therefore, by defining Length or Size type classes for those types.

In addition, the length syntax can be used with any object that has a field or method named length or a method named getLength. Similarly, the size syntax can be used with any object that has a field or method named size or a method named getSize. The type of a length or size field, or return type of a method, must be either Int or Long. Any such method must take no parameters. (The Scala compiler will ensure at compile time that the object on which should is being invoked has the appropriate structure.)

Checking strings

You can check for whether a string starts with, ends with, or includes a substring like this:

string should startWith ("Hello")
string should endWith ("world")
string should include ("seven")

You can check for whether a string starts with, ends with, or includes a regular expression, like this:

string should startWith regex "Hel*o"
string should endWith regex "wo.ld"
string should include regex "wo.ld"

And you can check whether a string fully matches a regular expression, like this:

string should fullyMatch regex """(-)?(\d+)(\.\d*)?"""

The regular expression passed following the regex token can be either a String or a scala.util.matching.Regex.

With the startWith, endWith, include, and fullyMatch tokens can also be used with an optional specification of required groups, like this:

"abbccxxx" should startWith regex ("a(b*)(c*)" withGroups ("bb", "cc"))
"xxxabbcc" should endWith regex ("a(b*)(c*)" withGroups ("bb", "cc"))
"xxxabbccxxx" should include regex ("a(b*)(c*)" withGroups ("bb", "cc"))
"abbcc" should fullyMatch regex ("a(b*)(c*)" withGroups ("bb", "cc"))

You can check whether a string is empty with empty:

s shouldBe empty

You can also use most of ScalaTest's matcher syntax for collections on String by treating the Strings as collections of characters. For examples, see the Strings and Arrays as collections section below.

Greater and less than

You can check whether any type for which an implicit Ordering[T] is available is greater than, less than, greater than or equal, or less than or equal to a value of type T. The syntax is:

one should be < 7
one should be > 0
one should be <= 7
one should be >= 0

Checking Boolean properties with be

If an object has a method that takes no parameters and returns boolean, you can check it by placing a Symbol (after be) that specifies the name of the method (excluding an optional prefix of "is"). A symbol literal in Scala begins with a tick mark and ends at the first non-identifier character. Thus, 'traversableAgain results in a Symbol object at runtime, as does 'completed and 'file. Here's an example:

iter shouldBe 'traversableAgain

Given this code, ScalaTest will use reflection to look on the object referenced from emptySet for a method that takes no parameters and results in Boolean, with either the name empty or isEmpty. If found, it will invoke that method. If the method returns true, execution will continue. But if it returns false, a TestFailedException will be thrown that will contain a detail message, such as:

non-empty iterator was not traversableAgain

This be syntax can be used with any reference (AnyRef) type. If the object does not have an appropriately named predicate method, you'll get a TestFailedException at runtime with a detailed message that explains the problem. (For the details on how a field or method is selected during this process, see the documentation for BeWord.)

If you think it reads better, you can optionally put a or an after be. For example, java.io.File has two predicate methods, isFile and isDirectory. Thus with a File object named temp, you could write:

temp should be a 'file

Or, given java.awt.event.KeyEvent has a method isActionKey that takes no arguments and returns Boolean, you could assert that a KeyEvent is an action key with:

keyEvent should be an 'actionKey

If you prefer to check Boolean properties in a type-safe manner, you can use a BePropertyMatcher. This would allow you to write expressions such as:

xs shouldBe traversableAgain
temp should be a file
keyEvent should be an actionKey

These expressions would fail to compile if should is used on an inappropriate type, as determined by the type parameter of the BePropertyMatcher being used. (For example, file in this example would likely be of type BePropertyMatcher[java.io.File]. If used with an appropriate type, such an expression will compile and at run time the Boolean property method or field will be accessed directly; i.e., no reflection will be used. See the documentation for BePropertyMatcher for more information.

Using custom BeMatchers

If you want to create a new way of using be, which doesn't map to an actual property on the type you care about, you can create a BeMatcher. You could use this, for example, to create BeMatcher[Int] called odd, which would match any odd Int, and even, which would match any even Int. Given this pair of BeMatchers, you could check whether an Int was odd or even with expressions like:

num shouldBe odd
num should not be even

For more information, see the documentation for BeMatcher.

Checking object identity

If you need to check that two references refer to the exact same object, you can write:

ref1 should be theSameInstanceAs ref2

Checking an object's class

If you need to check that an object is an instance of a particular class or trait, you can supply the type to “be a” or “be an”:

result1 shouldBe a [Tiger]
result1 should not be an [Orangutan]

Because type parameters are erased on the JVM, we recommend you insert an underscore for any type parameters when using this syntax. Both of the following test only that the result is an instance of List[_], because at runtime the type parameter has been erased:

result shouldBe a [List[_]] // recommended
result shouldBe a [List[Fruit]] // discouraged

Checking numbers against a range

Often you may want to check whether a number is within a range. You can do that using the +- operator, like this:

sevenDotOh should equal (6.9 +- 0.2)
sevenDotOh should === (6.9 +- 0.2)
sevenDotOh should be (6.9 +- 0.2)
sevenDotOh shouldEqual 6.9 +- 0.2
sevenDotOh shouldBe 6.9 +- 0.2

Any of these expressions will cause a TestFailedException to be thrown if the floating point value, sevenDotOh is outside the range 6.7 to 7.1. You can use +- with any type T for which an implicit Numeric[T] exists, such as integral types:

seven should equal (6 +- 2)
seven should === (6 +- 2)
seven should be (6 +- 2)
seven shouldEqual 6 +- 2
seven shouldBe 6 +- 2

Checking for emptiness

You can check whether an object is "empty", like this:

traversable shouldBe empty
javaMap should not be empty

The empty token can be used with any type L for which an implicit Emptiness[L] exists. The Emptiness companion object provides implicits for GenTraversable[E], java.util.Collection[E], java.util.Map[K, V], String, Array[E], and Option[E]. In addition, the Emptiness companion object provides structural implicits for types that declare an isEmpty method that returns a Boolean. Here are some examples:

scala> import org.scalatest.matchers.should.Matchers._
import org.scalatest.matchers.should.Matchers._

scala> List.empty shouldBe empty

scala> None shouldBe empty

scala> Some(1) should not be empty

scala> "" shouldBe empty

scala> new java.util.HashMap[Int, Int] shouldBe empty

scala> new { def isEmpty = true} shouldBe empty

scala> Array(1, 2, 3) should not be empty

Working with "containers"

You can check whether a collection contains a particular element like this:

traversable should contain ("five")

The contain syntax shown above can be used with any type C that has a "containing" nature, evidenced by an implicit org.scalatest.enablers.Containing[L], where L is left-hand type on which should is invoked. In the Containing companion object, implicits are provided for types GenTraversable[E], java.util.Collection[E], java.util.Map[K, V], String, Array[E], and Option[E]. Here are some examples:

scala> import org.scalatest.matchers.should.Matchers._
import org.scalatest.matchers.should.Matchers._

scala> List(1, 2, 3) should contain (2)

scala> Map('a' -> 1, 'b' -> 2, 'c' -> 3) should contain ('b' -> 2)

scala> Set(1, 2, 3) should contain (2)

scala> Array(1, 2, 3) should contain (2)

scala> "123" should contain ('2')

scala> Some(2) should contain (2)

ScalaTest's implicit methods that provide the Containing[L] type classes require an Equality[E], where E is an element type. For example, to obtain a Containing[Array[Int]] you must supply an Equality[Int], either implicitly or explicitly. The contain syntax uses this Equality[E] to determine containership. Thus if you want to change how containership is determined for an element type E, place an implicit Equality[E] in scope or use the explicitly DSL. Although the implicit parameter required for the contain syntax is of type Containing[L], implicit conversions are provided in the Containing companion object from Equality[E] to the various types of containers of E. Here's an example:

scala> import org.scalatest.matchers.should.Matchers._
import org.scalatest.matchers.should.Matchers._

scala> List("Hi", "Di", "Ho") should contain ("ho")
org.scalatest.exceptions.TestFailedException: List(Hi, Di, Ho) did not contain element "ho"
        at ...

scala> import org.scalactic.Explicitly._
import org.scalactic.Explicitly._

scala> import org.scalactic.StringNormalizations._
import org.scalactic.StringNormalizations._

scala> (List("Hi", "Di", "Ho") should contain ("ho")) (after being lowerCased)

Note that when you use the explicitly DSL with contain you need to wrap the entire contain expression in parentheses, as shown here.

(List("Hi", "Di", "Ho") should contain ("ho")) (after being lowerCased)
^                                            ^

In addition to determining whether an object contains another object, you can use contain to make other determinations. For example, the contain oneOf syntax ensures that one and only one of the specified elements are contained in the containing object:

List(1, 2, 3, 4, 5) should contain oneOf (5, 7, 9)
Some(7) should contain oneOf (5, 7, 9)
"howdy" should contain oneOf ('a', 'b', 'c', 'd')

Note that if multiple specified elements appear in the containing object, oneOf will fail:

scala> List(1, 2, 3) should contain oneOf (2, 3, 4)
org.scalatest.exceptions.TestFailedException: List(1, 2, 3) did not contain one (and only one) of (2, 3, 4)
        at ...

If you really want to ensure one or more of the specified elements are contained in the containing object, use atLeastOneOf, described below, instead of oneOf. Keep in mind, oneOf means "exactly one of."

Note also that with any contain syntax, you can place custom implicit Equality[E] instances in scope to customize how containership is determined, or use the explicitly DSL. Here's an example:

(Array("Doe", "Ray", "Me") should contain oneOf ("X", "RAY", "BEAM")) (after being lowerCased)

If you have a collection of elements that you'd like to use in a "one of" comparison, you can use "oneElementOf," like this:

List(1, 2, 3, 4, 5) should contain oneElementOf List(5, 7, 9)
Some(7) should contain oneElementOf Vector(5, 7, 9)
"howdy" should contain oneElementOf Set('a', 'b', 'c', 'd')
(Array("Doe", "Ray", "Me") should contain oneElementOf List("X", "RAY", "BEAM")) (after being lowerCased)

The contain noneOf syntax does the opposite of oneOf: it ensures none of the specified elements are contained in the containing object:

List(1, 2, 3, 4, 5) should contain noneOf (7, 8, 9)
Some(0) should contain noneOf (7, 8, 9)
"12345" should contain noneOf ('7', '8', '9')

If you have a collection of elements that you'd like to use in a "none of" comparison, you can use "noElementsOf," like this:

List(1, 2, 3, 4, 5) should contain noElementsOf List(7, 8, 9)
Some(0) should contain noElementsOf Vector(7, 8, 9)
"12345" should contain noElementsOf Set('7', '8', '9')

Working with "aggregations"

As mentioned, the "contain," "contain oneOf," and "contain noneOf" syntax requires a Containing[L] be provided, where L is the left-hand type. Other contain syntax, which will be described in this section, requires an Aggregating[L] be provided, where again L is the left-hand type. (An Aggregating[L] instance defines the "aggregating nature" of a type L.) The reason, essentially, is that contain syntax that makes sense for Option is enabled by Containing[L], whereas syntax that does not make sense for Option is enabled by Aggregating[L]. For example, it doesn't make sense to assert that an Option[Int] contains all of a set of integers, as it could only ever contain one of them. But this does make sense for a type such as List[Int] that can aggregate zero to many integers.

The Aggregating companion object provides implicit instances of Aggregating[L] for types GenTraversable[E], java.util.Collection[E], java.util.Map[K, V], String, Array[E]. Note that these are the same types as are supported with Containing, but with Option[E] missing. Here are some examples:

The contain atLeastOneOf syntax, for example, works for any type L for which an Aggregating[L] exists. It ensures that at least one of (i.e., one or more of) the specified objects are contained in the containing object:

List(1, 2, 3) should contain atLeastOneOf (2, 3, 4)
Array(1, 2, 3) should contain atLeastOneOf (3, 4, 5)
"abc" should contain atLeastOneOf ('c', 'a', 't')

Similar to Containing[L], the implicit methods that provide the Aggregating[L] instances require an Equality[E], where E is an element type. For example, to obtain a Aggregating[Vector[String]] you must supply an Equality[String], either implicitly or explicitly. The contain syntax uses this Equality[E] to determine containership. Thus if you want to change how containership is determined for an element type E, place an implicit Equality[E] in scope or use the explicitly DSL. Although the implicit parameter required for the contain syntax is of type Aggregating[L], implicit conversions are provided in the Aggregating companion object from Equality[E] to the various types of aggregations of E. Here's an example:

(Vector(" A", "B ") should contain atLeastOneOf ("a ", "b", "c")) (after being lowerCased and trimmed)

If you have a collection of elements that you'd like to use in an "at least one of" comparison, you can use "atLeastOneElementOf," like this:

List(1, 2, 3) should contain atLeastOneElementOf List(2, 3, 4)
Array(1, 2, 3) should contain atLeastOneElementOf Vector(3, 4, 5)
"abc" should contain atLeastOneElementOf Set('c', 'a', 't')
(Vector(" A", "B ") should contain atLeastOneElementOf List("a ", "b", "c")) (after being lowerCased and trimmed)

The "contain atMostOneOf" syntax lets you specify a set of objects at most one of which should be contained in the containing object:

List(1, 2, 3, 4, 5) should contain atMostOneOf (5, 6, 7)

If you have a collection of elements that you'd like to use in a "at most one of" comparison, you can use "atMostOneElementOf," like this:

List(1, 2, 3, 4, 5) should contain atMostOneElementOf Vector(5, 6, 7)

The "contain allOf" syntax lets you specify a set of objects that should all be contained in the containing object:

List(1, 2, 3, 4, 5) should contain allOf (2, 3, 5)

If you have a collection of elements that you'd like to use in a "all of" comparison, you can use "allElementsOf," like this:

List(1, 2, 3, 4, 5) should contain allElementsOf Array(2, 3, 5)

The "contain only" syntax lets you assert that the containing object contains only the specified objects, though it may contain more than one of each:

List(1, 2, 3, 2, 1) should contain only (1, 2, 3)

The "contain theSameElementsAs" and "contain theSameElementsInOrderAs syntax differ from the others in that the right hand side is a GenTraversable[_] rather than a varargs of Any. (Note: in a future 2.0 milestone release, possibly 2.0.M6, these will likely be widened to accept any type R for which an Aggregating[R] exists.)

The "contain theSameElementsAs" syntax lets you assert that two aggregations contain the same objects:

List(1, 2, 2, 3, 3, 3) should contain theSameElementsAs Vector(3, 2, 3, 1, 2, 3)

The number of times any family of equal objects appears must also be the same in both the left and right aggregations. The specified objects may appear multiple times, but must appear in the order they appear in the right-hand list. For example, if the last 3 element is left out of the right-hand list in the previous example, the expression would fail because the left side has three 3's and the right hand side has only two:

List(1, 2, 2, 3, 3, 3) should contain theSameElementsAs Vector(3, 2, 3, 1, 2)
org.scalatest.exceptions.TestFailedException: List(1, 2, 2, 3, 3, 3) did not contain the same elements as Vector(3, 2, 3, 1, 2)
        at ...

Note that no onlyElementsOf matcher is provided, because it would have the same behavior as theSameElementsAs. (I.e., if you were looking for onlyElementsOf, please use theSameElementsAs instead.)

Working with "sequences"

The rest of the contain syntax, which will be described in this section, requires a Sequencing[L] be provided, where again L is the left-hand type. (A Sequencing[L] instance defines the "sequencing nature" of a type L.) The reason, essentially, is that contain syntax that implies an "order" of elements makes sense only for types that place elements in a sequence. For example, it doesn't make sense to assert that a Map[String, Int] or Set[Int] contains all of a set of integers in a particular order, as these types don't necessarily define an order for their elements. But this does make sense for a type such as Seq[Int] that does define an order for its elements.

The Sequencing companion object provides implicit instances of Sequencing[L] for types GenSeq[E], java.util.List[E], String, and Array[E]. Here are some examples:

Similar to Containing[L], the implicit methods that provide the Aggregating[L] instances require an Equality[E], where E is an element type. For example, to obtain a Aggregating[Vector[String]] you must supply an Equality[String], either implicitly or explicitly. The contain syntax uses this Equality[E] to determine containership. Thus if you want to change how containership is determined for an element type E, place an implicit Equality[E] in scope or use the explicitly DSL. Although the implicit parameter required for the contain syntax is of type Aggregating[L], implicit conversions are provided in the Aggregating companion object from Equality[E] to the various types of aggregations of E. Here's an example:

The "contain inOrderOnly" syntax lets you assert that the containing object contains only the specified objects, in order. The specified objects may appear multiple times, but must appear in the order they appear in the right-hand list. Here's an example:

List(1, 2, 2, 3, 3, 3) should contain inOrderOnly (1, 2, 3)

The "contain inOrder" syntax lets you assert that the containing object contains only the specified objects in order, like inOrderOnly, but allows other objects to appear in the left-hand aggregation as well: contain more than one of each:

List(0, 1, 2, 2, 99, 3, 3, 3, 5) should contain inOrder (1, 2, 3)

If you have a collection of elements that you'd like to use in a "in order" comparison, you can use "inOrderElementsOf," like this:

List(0, 1, 2, 2, 99, 3, 3, 3, 5) should contain inOrderElementsOf Array(1, 2, 3)

Note that "order" in inOrder, inOrderOnly, and theSameElementsInOrderAs (described below) in the Aggregation[L] instances built-in to ScalaTest is defined as "iteration order".

Lastly, the "contain theSameElementsInOrderAs" syntax lets you assert that two aggregations contain the same exact elements in the same (iteration) order:

List(1, 2, 3) should contain theSameElementsInOrderAs collection.mutable.TreeSet(3, 2, 1)

The previous assertion succeeds because the iteration order of aTreeSet is the natural ordering of its elements, which in this case is 1, 2, 3. An iterator obtained from the left-hand List will produce the same elements in the same order.

Note that no inOrderOnlyElementsOf matcher is provided, because it would have the same behavior as theSameElementsInOrderAs. (I.e., if you were looking for inOrderOnlyElementsOf, please use theSameElementsInOrderAs instead.)

Working with "sortables"

You can also ask whether the elements of "sortable" objects (such as Arrays, Java Lists, and GenSeqs) are in sorted order, like this:

List(1, 2, 3) shouldBe sorted

Working with iterators

Although it seems desireable to provide similar matcher syntax for Scala and Java iterators to that provided for sequences like Seqs, Array, and java.util.List, the ephemeral nature of iterators makes this problematic. Some syntax (such as should contain) is relatively straightforward to support on iterators, but other syntax (such as, for example, Inspector expressions on nested iterators) is not. Rather than allowing inconsistencies between sequences and iterators in the API, we chose to not support any such syntax directly on iterators:

scala> val it = List(1, 2, 3).iterator
it: Iterator[Int] = non-empty iterator

scala> it should contain (2) <console>:15: error: could not find implicit value for parameter typeClass1: org.scalatest.enablers.Containing[Iterator[Int]] it should contain (2) ^

Instead, you will need to convert your iterators to a sequence explicitly before using them in matcher expressions:

scala> it.toStream should contain (2)

We recommend you convert (Scala or Java) iterators to Streams, as shown in the previous example, so that you can continue to reap any potential benefits provided by the laziness of the underlying iterator.

Inspector shorthands

You can use the Inspectors syntax with matchers as well as assertions. If you have a multi-dimensional collection, such as a list of lists, using Inspectors is your best option:

val yss =
  List(
    List(1, 2, 3),
    List(1, 2, 3),
    List(1, 2, 3)
  )

forAll (yss) { ys => forAll (ys) { y => y should be > 0 } }

For assertions on one-dimensional collections, however, matchers provides "inspector shorthands." Instead of writing:

val xs = List(1, 2, 3)
forAll (xs) { x => x should be < 10 }

You can write:

all (xs) should be < 10

The previous statement asserts that all elements of the xs list should be less than 10. All of the inspectors have shorthands in matchers. Here is the full list:

  • all - succeeds if the assertion holds true for every element
  • atLeast - succeeds if the assertion holds true for at least the specified number of elements
  • atMost - succeeds if the assertion holds true for at most the specified number of elements
  • between - succeeds if the assertion holds true for between the specified minimum and maximum number of elements, inclusive
  • every - same as all, but lists all failing elements if it fails (whereas all just reports the first failing element)
  • exactly - succeeds if the assertion holds true for exactly the specified number of elements

Here are some examples:

scala> import org.scalatest.matchers.should.Matchers._
import org.scalatest.matchers.should.Matchers._

scala> val xs = List(1, 2, 3, 4, 5)
xs: List[Int] = List(1, 2, 3, 4, 5)

scala> all (xs) should be > 0

scala> atMost (2, xs) should be >= 4

scala> atLeast (3, xs) should be < 5

scala> between (2, 3, xs) should (be > 1 and be < 5)

scala> exactly (2, xs) should be <= 2

scala> every (xs) should be < 10

scala> // And one that fails...

scala> exactly (2, xs) shouldEqual 2
org.scalatest.exceptions.TestFailedException: 'exactly(2)' inspection failed, because only 1 element
    satisfied the assertion block at index 1:
  at index 0, 1 did not equal 2,
  at index 2, 3 did not equal 2,
  at index 3, 4 did not equal 2,
  at index 4, 5 did not equal 2
in List(1, 2, 3, 4, 5)
        at ...

Like Inspectors, objects used with inspector shorthands can be any type T for which a Collecting[T, E] is availabe, which by default includes GenTraversable, Java Collection, Java Map, Arrays, and Strings. Here are some examples:

scala> import org.scalatest._
import org.scalatest._

scala> import matchers.should.Matchers._
import matchers.should.Matchers._

scala> all (Array(1, 2, 3)) should be < 5

scala> import collection.JavaConverters._
import collection.JavaConverters._

scala> val js = List(1, 2, 3).asJava
js: java.util.List[Int] = [1, 2, 3]

scala> all (js) should be < 5

scala> val jmap = Map("a" -> 1, "b" -> 2).asJava
jmap: java.util.Map[String,Int] = {a=1, b=2}

scala> atLeast(1, jmap) shouldBe Entry("b", 2)

scala> atLeast(2, "hello, world!") shouldBe 'o'

Single-element collections

To assert both that a collection contains just one "lone" element as well as something else about that element, you can use the loneElement syntax provided by trait LoneElement. For example, if a Set[Int] should contain just one element, an Int less than or equal to 10, you could write:

import LoneElement._
set.loneElement should be <= 10

You can invoke loneElement on any type T for which an implicit Collecting[E, T] is available, where E is the element type returned by the loneElement invocation. By default, you can use loneElement on GenTraversable, Java Collection, Java Map, Array, and String.

Java collections and maps

You can use similar syntax on Java collections (java.util.Collection) and maps (java.util.Map). For example, you can check whether a Java Collection or Map is empty, like this:

javaCollection should be ('empty)
javaMap should be ('empty)

Even though Java's List type doesn't actually have a length or getLength method, you can nevertheless check the length of a Java List (java.util.List) like this:

javaList should have length 9

You can check the size of any Java Collection or Map, like this:

javaMap should have size 20
javaSet should have size 90

In addition, you can check whether a Java Collection contains a particular element, like this:

javaCollection should contain ("five")

One difference to note between the syntax supported on Java and Scala collections is that in Java, Map is not a subtype of Collection, and does not actually define an element type. You can ask a Java Map for an "entry set" via the entrySet method, which will return the Map's key/value pairs wrapped in a set of java.util.Map.Entry, but a Map is not actually a collection of Entry. To make Java Maps easier to work with, however, ScalaTest matchers allows you to treat a Java Map as a collection of Entry, and defines a convenience implementation of java.util.Map.Entry in org.scalatest.Entry. Here's how you use it:

javaMap should contain (Entry(2, 3))
javaMap should contain oneOf (Entry(2, 3), Entry(3, 4))

You can you alse just check whether a Java Map contains a particular key, or value, like this:

javaMap should contain key 1
javaMap should contain value "Howdy"

Strings and Arrays as collections

You can also use all the syntax described above for Scala and Java collections on Arrays and Strings. Here are some examples:

scala> import org.scalatest._
import org.scalatest._

scala> import matchers.should.Matchers._
import matchers.should.Matchers._

scala> atLeast (2, Array(1, 2, 3)) should be > 1

scala> atMost (2, "halloo") shouldBe 'o'

scala> Array(1, 2, 3) shouldBe sorted

scala> "abcdefg" shouldBe sorted

scala> Array(1, 2, 3) should contain atMostOneOf (3, 4, 5)

scala> "abc" should contain atMostOneOf ('c', 'd', 'e')

be as an equality comparison

All uses of be other than those shown previously perform an equality comparison. They work the same as equal when it is used with default equality. This redundancy between be and equals exists in part because it enables syntax that sometimes sounds more natural. For example, instead of writing:

result should equal (null)

You can write:

result should be (null)

(Hopefully you won't write that too much given null is error prone, and Option is usually a better, well, option.) As mentioned previously, the other difference between equal and be is that equal delegates the equality check to an Equality typeclass, whereas be always uses default equality. Here are some other examples of be used for equality comparison:

sum should be (7.0)
boring should be (false)
fun should be (true)
list should be (Nil)
option should be (None)
option should be (Some(1))

As with equal used with default equality, using be on arrays results in deep being called on both arrays prior to calling equal. As a result, the following expression would not throw a TestFailedException:

Array(1, 2) should be (Array(1, 2)) // succeeds (i.e., does not throw TestFailedException)

Because be is used in several ways in ScalaTest matcher syntax, just as it is used in many ways in English, one potential point of confusion in the event of a failure is determining whether be was being used as an equality comparison or in some other way, such as a property assertion. To make it more obvious when be is being used for equality, the failure messages generated for those equality checks will include the word equal in them. For example, if this expression fails with a TestFailedException:

option should be (Some(1))

The detail message in that TestFailedException will include the words "equal to" to signify be was in this case being used for equality comparison:

Some(2) was not equal to Some(1)

Being negative

If you wish to check the opposite of some condition, you can simply insert not in the expression. Here are a few examples:

result should not be (null)
sum should not be <= (10)
mylist should not equal (yourList)
string should not startWith ("Hello")

Checking that a snippet of code does not compile

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 Matchers trait includes the following syntax for that purpose:

"val a: String = 1" shouldNot compile

If you want to ensure that a snippet of code does not compile because of a type error (as opposed to a syntax error), use:

"val a: String = 1" shouldNot typeCheck

Note that the shouldNot typeCheck syntax will only succeed if the given snippet of code does not compile because of a type error. A syntax error will still result on a thrown TestFailedException.

If you want to state that a snippet of code does compile, you can make that more obvious with:

"val a: Int = 1" should compile

Although the previous three constructs are implemented with macros that determine at compile time whether the snippet of code represented by the string does or does not compile, errors are reported as test failures at runtime.

Logical expressions with and and or

You can also combine matcher expressions with and and/or or, however, you must place parentheses or curly braces around the and or or expression. For example, this and-expression would not compile, because the parentheses are missing:

map should contain key ("two") and not contain value (7) // ERROR, parentheses missing!

Instead, you need to write:

map should (contain key ("two") and not contain value (7))

Here are some more examples:

number should (be > (0) and be <= (10))
option should (equal (Some(List(1, 2, 3))) or be (None))
string should (
  equal ("fee") or
  equal ("fie") or
  equal ("foe") or
  equal ("fum")
)

Two differences exist between expressions composed of these and and or operators and the expressions you can write on regular Booleans using its && and || operators. First, expressions with and and or do not short-circuit. The following contrived expression, for example, would print "hello, world!":

"yellow" should (equal ("blue") and equal { println("hello, world!"); "green" })

In other words, the entire and or or expression is always evaluated, so you'll see any side effects of the right-hand side even if evaluating only the left-hand side is enough to determine the ultimate result of the larger expression. Failure messages produced by these expressions will "short-circuit," however, mentioning only the left-hand side if that's enough to determine the result of the entire expression. This "short-circuiting" behavior of failure messages is intended to make it easier and quicker for you to ascertain which part of the expression caused the failure. The failure message for the previous expression, for example, would be:

"yellow" did not equal "blue"

Most likely this lack of short-circuiting would rarely be noticeable, because evaluating the right hand side will usually not involve a side effect. One situation where it might show up, however, is if you attempt to and a null check on a variable with an expression that uses the variable, like this:

map should (not be (null) and contain key ("ouch"))

If map is null, the test will indeed fail, but with a NullArgumentException, not a TestFailedException. Here, the NullArgumentException is the visible right-hand side effect. To get a TestFailedException, you would need to check each assertion separately:

map should not be (null)
map should contain key ("ouch")

If map is null in this case, the null check in the first expression will fail with a TestFailedException, and the second expression will never be executed.

The other difference with Boolean operators is that although && has a higher precedence than ||, and and or have the same precedence. Thus although the Boolean expression (a || b && c) will evaluate the && expression before the || expression, like (a || (b && c)), the following expression:

traversable should (contain (7) or contain (8) and have size (9))

Will evaluate left to right, as:

traversable should ((contain (7) or contain (8)) and have size (9))

If you really want the and part to be evaluated first, you'll need to put in parentheses, like this:

traversable should (contain (7) or (contain (8) and have size (9)))

Working with Options

You can work with options using ScalaTest's equality, empty, defined, and contain syntax. For example, if you wish to check whether an option is None, you can write any of:

option shouldEqual None
option shouldBe None
option should === (None)
option shouldBe empty

If you wish to check an option is defined, and holds a specific value, you can write any of:

option shouldEqual Some("hi")
option shouldBe Some("hi")
option should === (Some("hi"))

If you only wish to check that an option is defined, but don't care what it's value is, you can write:

option shouldBe defined

If you mix in (or import the members of) OptionValues, you can write one statement that indicates you believe an option should be defined and then say something else about its value. Here's an example:

import org.scalatest.OptionValues._
option.value should be < 7

As mentioned previously, you can use also use ScalaTest's contain, contain oneOf, and contain noneOf syntax with options:

Some(2) should contain (2)
Some(7) should contain oneOf (5, 7, 9)
Some(0) should contain noneOf (7, 8, 9)

Checking arbitrary properties with have

Using have, you can check properties of any type, where a property is an attribute of any object that can be retrieved either by a public field, method, or JavaBean-style get or is method, like this:

book should have (
  'title ("Programming in Scala"),
  'author (List("Odersky", "Spoon", "Venners")),
  'pubYear (2008)
)

This expression will use reflection to ensure the title, author, and pubYear properties of object book are equal to the specified values. For example, it will ensure that book has either a public Java field or method named title, or a public method named getTitle, that when invoked (or accessed in the field case) results in a the string "Programming in Scala". If all specified properties exist and have their expected values, respectively, execution will continue. If one or more of the properties either does not exist, or exists but results in an unexpected value, a TestFailedException will be thrown that explains the problem. (For the details on how a field or method is selected during this process, see the documentation for HavePropertyMatcherGenerator.)

When you use this syntax, you must place one or more property values in parentheses after have, seperated by commas, where a property value is a symbol indicating the name of the property followed by the expected value in parentheses. The only exceptions to this rule is the syntax for checking size and length shown previously, which does not require parentheses. If you forget and put parentheses in, however, everything will still work as you'd expect. Thus instead of writing:

array should have length (3)
set should have size (90)

You can alternatively, write:

array should have (length (3))
set should have (size (90))

If a property has a value different from the specified expected value, a TestFailedError will be thrown with a detailed message that explains the problem. For example, if you assert the following on a book whose title is Moby Dick:

book should have ('title ("A Tale of Two Cities"))

You'll get a TestFailedException with this detail message:

The title property had value "Moby Dick", instead of its expected value "A Tale of Two Cities",
on object Book("Moby Dick", "Melville", 1851)

If you prefer to check properties in a type-safe manner, you can use a HavePropertyMatcher. This would allow you to write expressions such as:

book should have (
  title ("Programming in Scala"),
  author (List("Odersky", "Spoon", "Venners")),
  pubYear (2008)
)

These expressions would fail to compile if should is used on an inappropriate type, as determined by the type parameter of the HavePropertyMatcher being used. (For example, title in this example might be of type HavePropertyMatcher[org.publiclibrary.Book]. If used with an appropriate type, such an expression will compile and at run time the property method or field will be accessed directly; i.e., no reflection will be used. See the documentation for HavePropertyMatcher for more information.

Using length and size with HavePropertyMatchers

If you want to use length or size syntax with your own custom HavePropertyMatchers, you can do so, but you must write (of [“the type”]) afterwords. For example, you could write:

book should have (
  title ("A Tale of Two Cities"),
  length (220) (of [Book]),
  author ("Dickens")
)

Prior to ScalaTest 2.0, “length (22)” yielded a HavePropertyMatcher[Any, Int] that used reflection to dynamically look for a length field or getLength method. In ScalaTest 2.0, “length (22)” yields a MatcherFactory1[Any, Length], so it is no longer a HavePropertyMatcher. The (of [<type>]) syntax converts the the MatcherFactory1[Any, Length] to a HavePropertyMatcher[<type>, Int].

Checking that an expression matches a pattern

ScalaTest's Inside trait allows you to make assertions after a pattern match. Here's an example:

case class Name(first: String, middle: String, last: String)

val name = Name("Jane", "Q", "Programmer")
inside(name) { case Name(first, _, _) => first should startWith ("S") }

You can use inside to just ensure a pattern is matched, without making any further assertions, but a better alternative for that kind of assertion is matchPattern. The matchPattern syntax allows you to express that you expect a value to match a particular pattern, no more and no less:

name should matchPattern { case Name("Sarah", _, _) => }

Using custom matchers

If none of the built-in matcher syntax (or options shown so far for extending the syntax) satisfy a particular need you have, you can create custom Matchers that allow you to place your own syntax directly after should. For example, class java.io.File has a method isHidden, which indicates whether a file of a certain path and name is hidden. Because the isHidden method takes no parameters and returns Boolean, you can call it using be with a symbol or BePropertyMatcher, yielding assertions like:

file should be ('hidden)  // using a symbol
file should be (hidden)   // using a BePropertyMatcher

If it doesn't make sense to have your custom syntax follow be, you might want to create a custom Matcher instead, so your syntax can follow should directly. For example, you might want to be able to check whether a java.io.File's name ends with a particular extension, like this:

// using a plain-old Matcher
file should endWithExtension ("txt")

ScalaTest provides several mechanism to make it easy to create custom matchers, including ways to compose new matchers out of existing ones complete with new error messages. For more information about how to create custom Matchers, please see the documentation for the Matcher trait.

Checking for expected exceptions

Sometimes you need to test whether a method throws an expected exception under certain circumstances, such as when invalid arguments are passed to the method. With Matchers mixed in, you can check for an expected exception like this:

an [IndexOutOfBoundsException] should be thrownBy s.charAt(-1)

If charAt throws an instance of StringIndexOutOfBoundsException, this expression will result in that exception. But if charAt completes normally, or throws a different exception, this expression will complete abruptly with a TestFailedException.

If you need to further isnpect an expected exception, you can capture it using this syntax:

val thrown = the [IndexOutOfBoundsException] thrownBy s.charAt(-1)

This expression returns the caught exception so that you can inspect it further if you wish, for example, to ensure that data contained inside the exception has the expected values. Here's an example:

thrown.getMessage should equal ("String index out of range: -1")

If you prefer you can also capture and inspect an expected exception in one statement, like this:

the [ArithmeticException] thrownBy 1 / 0 should have message "/ by zero"
the [IndexOutOfBoundsException] thrownBy {
  s.charAt(-1)
} should have message "String index out of range: -1"

You can also state that no exception should be thrown by some code, like this:

noException should be thrownBy 0 / 1

Those pesky parens

Perhaps the most tricky part of writing assertions using ScalaTest matchers is remembering when you need or don't need parentheses, but bearing in mind a few simple rules should help. It is also reassuring to know that if you ever leave off a set of parentheses when they are required, your code will not compile. Thus the compiler will help you remember when you need the parens. That said, the rules are:

1. Although you don't always need them, you may choose to always put parentheses around right-hand values, such as the 7 in num should equal (7):

result should equal (4)
array should have length (3)
book should have (
  'title ("Programming in Scala"),
  'author (List("Odersky", "Spoon", "Venners")),
  'pubYear (2008)
)
option should be ('defined)
catMap should (contain key (9) and contain value ("lives"))
keyEvent should be an ('actionKey)
javaSet should have size (90)

2. Except for length, size and message, you must always put parentheses around the list of one or more property values following a have:

file should (exist and have ('name ("temp.txt")))
book should have (
  title ("Programming in Scala"),
  author (List("Odersky", "Spoon", "Venners")),
  pubYear (2008)
)
javaList should have length (9) // parens optional for length and size

3. You must always put parentheses around and and or expressions, as in:

catMap should (contain key (9) and contain value ("lives"))
number should (equal (2) or equal (4) or equal (8))

4. Although you don't always need them, you may choose to always put parentheses around custom Matchers when they appear directly after not:

file should exist
file should not (exist)
file should (exist and have ('name ("temp.txt")))
file should (not (exist) and have ('name ("temp.txt"))
file should (have ('name ("temp.txt") or exist)
file should (have ('name ("temp.txt") or not (exist))

That's it. With a bit of practice it should become natural to you, and the compiler will always be there to tell you if you forget a set of needed parentheses.

Note: ScalaTest's matchers are in part inspired by the matchers of RSpec, Hamcrest, and specs2, and its “shouldNot compile” syntax by the illTyped macro of shapeless.

Self Type
Matchers
Source
Matchers.scala
Linear Supertypes
Explicitly, MatcherWords, ShouldVerb, Tolerance, Assertions, TripleEquals, TripleEqualsSupport, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Matchers
  2. Explicitly
  3. MatcherWords
  4. ShouldVerb
  5. Tolerance
  6. Assertions
  7. TripleEquals
  8. TripleEqualsSupport
  9. AnyRef
  10. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final class AWord extends AnyRef

    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.

  2. final class AnWord extends AnyRef

    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.

  3. sealed class AnyShouldWrapper[T] extends AnyRef

    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 should methods to be invoked on objects of type Any.

  4. class CheckingEqualizer[L] extends AnyRef
    Definition Classes
    TripleEqualsSupport
  5. sealed class Collected extends Serializable
    Attributes
    protected
  6. class DecidedByEquality[A] extends Equality[A]
    Definition Classes
    Explicitly
  7. class DecidedWord extends AnyRef
    Definition Classes
    Explicitly
  8. class DeterminedByEquivalence[T] extends Equivalence[T]
    Definition Classes
    Explicitly
  9. class DeterminedWord extends AnyRef
    Definition Classes
    Explicitly
  10. class Equalizer[L] extends AnyRef
    Definition Classes
    TripleEqualsSupport
  11. final class HavePropertyMatcherGenerator extends AnyRef

    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)

  12. final class KeyWord extends AnyRef

    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.

  13. final class PlusOrMinusWrapper[T] extends AnyRef
    Definition Classes
    Tolerance
  14. final class RegexWord extends AnyRef

    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.

  15. final class RegexWrapper extends AnyRef

    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.

  16. class ResultOfBeWordForAny[T] extends AnyRef

    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.

  17. sealed class ResultOfBeWordForCollectedAny[T] extends AnyRef

    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.

  18. final class ResultOfBeWordForCollectedArray[T] extends ResultOfBeWordForCollectedAny[Array[T]]

    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.

  19. final class ResultOfCollectedAny[T] extends AnyRef

    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.

  20. final class ResultOfContainWordForCollectedAny[T] extends AnyRef

    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.

  21. final class ResultOfEndWithWordForCollectedString extends AnyRef

    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.

  22. final class ResultOfEndWithWordForString extends AnyRef

    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.

  23. final class ResultOfFullyMatchWordForCollectedString extends AnyRef

    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.

  24. final class ResultOfFullyMatchWordForString extends AnyRef

    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.

  25. final class ResultOfHaveWordForCollectedExtent[A] extends AnyRef

    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.

  26. final class ResultOfHaveWordForExtent[A] extends AnyRef

    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.

  27. final class ResultOfIncludeWordForCollectedString extends AnyRef

    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.

  28. final class ResultOfIncludeWordForString extends AnyRef

    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.

  29. final class ResultOfNotWordForCollectedAny[T] extends AnyRef

    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.

  30. final class ResultOfStartWithWordForCollectedString extends AnyRef

    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.

  31. final class ResultOfStartWithWordForString extends AnyRef

    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.

  32. final class StringShouldWrapper extends AnyShouldWrapper[String] with StringShouldWrapperForVerb

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

  33. class TheAfterWord extends AnyRef
    Definition Classes
    Explicitly
  34. final class TheSameInstanceAsPhrase extends AnyRef

    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.

  35. final class ValueWord extends AnyRef

    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.

  36. trait StringShouldWrapperForVerb 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 should methods to be invoked on Strings.

    Definition Classes
    ShouldVerb

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]
    Definition Classes
    TripleEqualsSupport
  3. def !==(right: Null): TripleEqualsInvocation[Null]
    Definition Classes
    TripleEqualsSupport
  4. def !==[T](right: T): TripleEqualsInvocation[T]
    Definition Classes
    TripleEqualsSupport
  5. final def ##(): Int
    Definition Classes
    AnyRef → Any
  6. def <[T](right: T)(implicit arg0: Ordering[T]): ResultOfLessThanComparison[T]

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  8. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]
    Definition Classes
    TripleEqualsSupport
  10. def ===(right: Null): TripleEqualsInvocation[Null]
    Definition Classes
    TripleEqualsSupport
  11. def ===[T](right: T): TripleEqualsInvocation[T]
    Definition Classes
    TripleEqualsSupport
  12. def >[T](right: T)(implicit arg0: Ordering[T]): ResultOfGreaterThanComparison[T]

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  15. val a: AWord

    This field enables the following syntax:

    This field enables the following syntax:

    badBook should not be a ('goodRead)
                          ^
    

  16. val after: TheAfterWord
    Definition Classes
    Explicitly
  17. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  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]]

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

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

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

  19. def all[K, V, MAP[k, v] <: GenMap[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

    This method enables the following syntax for scala.collection.GenMap:

    This method enables the following syntax for scala.collection.GenMap:

    all(map) should fullymatch regex ("Hel*o world".r)
    ^
    

  20. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  22. 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) should contain (allOf(1, 2))
                                  ^
    

  23. def an[T](implicit arg0: ClassTag[T]): ResultOfAnTypeInvocation[T]

    This method enables the following syntax:

    This method enables the following syntax:

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

  24. val an: AnWord

    This field enables the following syntax:

    This field enables the following syntax:

    badBook should not be an (excellentRead)
                          ^
    

  25. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  26. macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    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.

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

    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.

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

    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
  29. macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

    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
  30. def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    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.

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

    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.

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

    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.

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

    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
  34. macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

    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

    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]

    This method enables the following syntax for String:

    This method enables the following syntax for String:

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

  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]]

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

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

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

  38. def atLeast[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

    This method enables the following syntax for scala.collection.GenMap:

    This method enables the following syntax for scala.collection.GenMap:

    atLeast(1, map) should fullymatch regex ("Hel*o world".r)
    ^
    

  39. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  41. 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) should contain (atLeastOneOf(1, 2))
                                  ^
    

  42. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  43. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  44. def atMost[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

    This method enables the following syntax for scala.collection.GenMap:

    This method enables the following syntax for scala.collection.GenMap:

    atMost(3, map) should fullymatch regex ("Hel*o world".r)
    ^
    

  45. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  47. 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) should contain (atMostOneOf(1, 2))
                                  ^
    

  48. val be: BeWord

    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
  49. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  50. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  51. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  52. def cancel(cause: Throwable)(implicit pos: Position): Nothing

    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

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

    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

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

    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

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

    Throws TestCanceledException to indicate a test was canceled.

    Throws TestCanceledException to indicate a test was canceled.

    Definition Classes
    Assertions
  56. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  57. val compile: CompileWord

    This field enables the following syntax:

    This field enables the following syntax:

    "val a: String = 1" shouldNot compile
                                  ^
    

    Definition Classes
    MatcherWords
  58. val contain: ContainWord

    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
  59. def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  60. def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  61. implicit def convertNumericToPlusOrMinusWrapper[T](pivot: T)(implicit arg0: Numeric[T]): PlusOrMinusWrapper[T]
    Definition Classes
    Tolerance
  62. implicit def convertSymbolToHavePropertyMatcherGenerator(symbol: Symbol)(implicit prettifier: Prettifier, pos: Position): HavePropertyMatcherGenerator

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

  63. implicit def convertToAnyShouldWrapper[T](o: T)(implicit pos: Position, prettifier: Prettifier): AnyShouldWrapper[T]

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

  64. def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  65. implicit def convertToEqualizer[T](left: T): Equalizer[T]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  66. 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.

  67. implicit def convertToStringShouldWrapper(o: String)(implicit pos: Position, prettifier: Prettifier): StringShouldWrapper

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

  68. implicit def convertToStringShouldWrapperForVerb(o: String)(implicit position: Position): StringShouldWrapperForVerb

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

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

    Definition Classes
    ShouldVerb
  69. val decided: DecidedWord
    Definition Classes
    Explicitly
  70. def defaultEquality[A]: Equality[A]
    Definition Classes
    TripleEqualsSupport
  71. val defined: DefinedWord

    This field enables the following syntax:

    This field enables the following syntax:

    seq should be (defined)
                  ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  73. val determined: DeterminedWord
    Definition Classes
    Explicitly
  74. val empty: EmptyWord

    This field enables the following syntax:

    This field enables the following syntax:

    list should be (empty)
                    ^
    

    Definition Classes
    MatcherWords
  75. val endWith: EndWithWord

    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
  76. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  77. def equal(o: Null): Matcher[AnyRef]

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    result should equal (null)
                  ^
    

  78. 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 should equal (100 +- 1)
                  ^
    

  79. def equal(right: Any): MatcherFactory1[Any, Equality]

    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
  80. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  81. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  82. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  83. def every[K, V, MAP[k, v] <: Map[k, v]](xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

    This method enables the following syntax for scala.collection.GenMap:

    This method enables the following syntax for scala.collection.GenMap:

    every(map) should fullymatch regex ("Hel*o world".r)
    ^
    

  84. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  85. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  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]]

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

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

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

  87. def exactly[K, V, MAP[k, v] <: GenMap[k, v]](num: Int, xs: MAP[K, V])(implicit collecting: Collecting[(K, V), GenTraversable[(K, V)]], prettifier: Prettifier, pos: Position): ResultOfCollectedAny[(K, V)]

    This method enables the following syntax for scala.collection.GenMap:

    This method enables the following syntax for scala.collection.GenMap:

    exactly(map) should fullymatch regex ("Hel*o world".r)
    ^
    

  88. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  89. val exist: ExistWord

    This field enables the following syntax:

    This field enables the following syntax:

    file should exist
                ^
    

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

    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

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

    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

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

    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

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

    Throws TestFailedException to indicate a test failed.

    Throws TestFailedException to indicate a test failed.

    Definition Classes
    Assertions
  94. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  95. val fullyMatch: FullyMatchWord

    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
  96. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  97. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  98. val have: HaveWord

    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
  99. 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) should contain (inOrder(1, 2))
                                  ^
    

  100. def inOrderElementsOf[R](elements: GenTraversable[R]): ResultOfInOrderElementsOfApplication

    This method enables the following syntax:

    This method enables the following syntax:

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

  101. 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) should contain (inOrderOnly(1, 2))
                                  ^
    

  102. val include: IncludeWord

    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
  103. def intercept[T <: AnyRef](f: => Any)(implicit classTag: ClassTag[T], pos: Position): T

    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.

  104. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  105. val key: KeyWord

    This field enables the following syntax:

    This field enables the following syntax:

    map should not contain key (10)
                           ^
    

  106. val length: LengthWord

    This field enables the following syntax:

    This field enables the following syntax:

    "hi" should not have length (3)
                         ^
    

    Definition Classes
    MatcherWords
  107. def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  108. val matchPattern: MatchPatternWord

    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

    This method enables the following syntax:

    This method enables the following syntax:

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

  110. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  111. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

  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]]

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

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

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

  113. 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) should fullymatch regex ("Hel*o world".r)
    ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  115. def noException(implicit pos: Position): NoExceptionWord

    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

    This method enables the following syntax:

    This method enables the following syntax:

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

  117. val not: NotWord

    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
    Definition Classes
    AnyRef
    Annotations
    @native()
  119. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  120. 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 should have (message ("A TALE OF TWO CITIES") (of [Book]), title ("A Tale of Two Cities"))
                                                        ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  122. 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) should contain (oneOf(1, 2))
                                  ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  124. def pending: Assertion with PendingStatement

    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

    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

    This field enables the following syntax:

    This field enables the following syntax:

    file should be (readable)
                    ^
    

    Definition Classes
    MatcherWords
  127. val regex: RegexWord

    This field enables the following syntax:

    This field enables the following syntax:

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

  128. val size: SizeWord

    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

    This field enables the following syntax:

    This field enables the following syntax:

    seq should be (sorted)
                  ^
    

    Definition Classes
    MatcherWords
  130. val startWith: StartWithWord

    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

    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
    Definition Classes
    AnyRef
  133. 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] should be thrownBy { ... }
    ^
    

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

    This method enables the following syntax:

    This method enables the following syntax:

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

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

    This method enables the following syntax:

    This method enables the following syntax:

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

  136. val theSameInstanceAs: TheSameInstanceAsPhrase

    This field enables the following syntax:

    This field enables the following syntax:

    oneString should not be theSameInstanceAs (anotherString)
                            ^
    

  137. def thrownBy(fun: => Any): ResultOfThrownByApplication

    This method enables the following syntax:

    This method enables the following syntax:

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

  138. def toString(): String
    Definition Classes
    AnyRef → Any
  139. val typeCheck: TypeCheckWord

    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]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  141. implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
  142. val value: ValueWord

    This field enables the following syntax:

    This field enables the following syntax:

    map should not contain value (10)
                           ^
    

  143. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  144. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  145. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  146. def withClue[T](clue: Any)(fun: => T): T

    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

    This field enables the following syntax:

    This field enables the following syntax:

    file should be (writable)
                    ^
    

    Definition Classes
    MatcherWords

Deprecated Value Members

  1. def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) => A): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
    Annotations
    @deprecated
    Deprecated

    (Since version 3.1.0) The conversionCheckedConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.

  2. def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) => B): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
    Annotations
    @deprecated
    Deprecated

    (Since version 3.1.0) The convertEquivalenceToAToBConversionConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.

  3. def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) => A): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
    Annotations
    @deprecated
    Deprecated

    (Since version 3.1.0) The convertEquivalenceToBToAConversionConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.

  4. def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) => B): CanEqual[A, B]
    Definition Classes
    TripleEquals → TripleEqualsSupport
    Annotations
    @deprecated
    Deprecated

    (Since version 3.1.0) The lowPriorityConversionCheckedConstraint method has been deprecated and will be removed in a future version of ScalaTest. It is no longer needed now that the deprecation period of ConversionCheckedTripleEquals has expired. It will not be replaced.

Inherited from Explicitly

Inherited from MatcherWords

Inherited from ShouldVerb

Inherited from Tolerance

Inherited from Assertions

Inherited from TripleEquals

Inherited from TripleEqualsSupport

Inherited from AnyRef

Inherited from Any

Ungrouped