final defasInstanceOf[T0]: T0

Definition Classes

Any

defassert(condition: Boolean, clue: Any): Unit

Assert that a boolean condition, described in Stringmessage, is true.

Assert that a boolean condition, described in Stringmessage, 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,
not Option[String] to be the default in tests. This makes === consistent between tests and production
code. If you have pre-existing code you wrote under ScalaTest 1.x, in which you are expecting=== to return an
Option[String], use can get that behavior back by mixing in trait LegacyTripleEquals.

condition

the boolean condition to assert

clue

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

defassert(condition: Boolean): Unit

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,
not Option[String] to be the default in tests. This makes === consistent between tests and production
code. If you have pre-existing code you wrote under ScalaTest 1.x, in which you are expecting=== to return an
Option[String], use can get that behavior back by mixing in trait LegacyTripleEquals.

defassertCompiles(code: String): Unit

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.

defassertDoesNotCompile(code: String): Unit

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.

defassertResult(expected: Any, clue: Any)(actual: Any): Unit

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.

defassertTypeError(code: String): Unit

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.

defassume(condition: Boolean, clue: Any): Unit

Assume that a boolean condition, described in Stringmessage, is true.

Assume that a boolean condition, described in Stringmessage, 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,
not Option[String] to be the default in tests. This makes === consistent between tests and production
code. If you have pre-existing code you wrote under ScalaTest 1.x, in which you are expecting=== to return an
Option[String], use can get that behavior back by mixing in trait LegacyTripleEquals.

condition

the boolean condition to assume

clue

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

defassume(condition: Boolean): Unit

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,
not Option[String] to be the default in tests. This makes === consistent between tests and production
code. If you have pre-existing code you wrote under ScalaTest 1.x, in which you are expecting=== to return an
Option[String], use can get that behavior back by mixing in trait LegacyTripleEquals.

Provides a Constraint[A, B] for any two types A and B, enforcing the type constraint
that B must be a subtype of A, given an explicitEquivalence[A].

Provides a Constraint[A, B] for any two types A and B, enforcing the type constraint
that B must be a subtype of A, given an explicitEquivalence[A].

This method is used to enable the Explicitly DSL for
TypeCheckedTripleEquals by requiring an explicit Equivalance[B], but
taking an implicit function that provides evidence that A is a subtype of B. For example, under TypeCheckedTripleEquals,
this method (as an implicit method), would be used to compile this statement:

Provides a Constraint[A, B] class for any two types A and B, enforcing the type constraint that B is
implicitly convertible to A, given an explicitEquivalence[A].

Provides a Constraint[A, B] class for any two types A and B, enforcing the type constraint that B is
implicitly convertible to A, given an explicitEquivalence[A].

This method is used to enable the Explicitly DSL for
ConversionCheckedTripleEquals by requiring an explicit Equivalance[A], but
taking an implicit function that converts from B to A. For example, under ConversionCheckedTripleEquals,
this method (as an implicit method), would be used to compile this statement:

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:

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.

f

the function value that should throw the expected exception

manifest

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

deftoString(): String

deftrap[T](f: ⇒ T): Throwable

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

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

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

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

scala> import Matchers._
import Matchers._

scala> val x = 12
a: Int = 12

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

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

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

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

final defwait(): Unit

final defwait(arg0: Long, arg1: Int): Unit

Definition Classes

AnyRef

Annotations

@throws()

final defwait(arg0: Long): Unit

Definition Classes

AnyRef

Annotations

@throws()

defwithClue[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:

Deprecated Value Members

defassert(o: Option[String]): Unit

Assert that an Option[String] is None.

Assert that an Option[String] is None.
If the condition is None, this method returns normally.
Else, it throws TestFailedException with the String
value of the Some included in the TestFailedException's
detail message.

This form of assert is usually called in conjunction with an
implicit conversion to Equalizer, using a === comparison, as in:

This method has been deprecated in favor of macro assertion and will be removed in a future version of ScalaTest. If you need this, please copy the source code into your own trait instead.

Exceptions thrown

TestFailedException

if the Option[String] is Some.

defassert(o: Option[String], clue: Any): Unit

Assert that an Option[String] is None.

Assert that an Option[String] is None.
If the condition is None, this method returns normally.
Else, it throws TestFailedException with the String
value of the Some, as well as the
String obtained by invoking toString on the
specified clue,
included in the TestFailedException's detail message.

This form of assert is usually called in conjunction with an
implicit conversion to Equalizer, using a === comparison, as in:

This method has been deprecated in favor of macro assertion and will be removed in a future version of ScalaTest. If you need this, please copy the source code into your own trait instead.

Exceptions thrown

NullPointerException

if message is null.

TestFailedException

if the Option[String] is Some.

defassume(o: Option[String]): Unit

Assume that an Option[String] is None.

Assume that an Option[String] is None.
If the condition is None, this method returns normally.
Else, it throws TestCanceledException with the String
value of the Some included in the TestCanceledException's
detail message.

This form of assume is usually called in conjunction with an
implicit conversion to Equalizer, using a === comparison, as in:

This method has been deprecated in favor of macro assumption and will be removed in a future version of ScalaTest. If you need this, please copy the source code into your own trait instead.

Exceptions thrown

TestCanceledException

if the Option[String] is Some.

defassume(o: Option[String], clue: Any): Unit

Assume that an Option[String] is None.

Assume that an Option[String] is None.
If the condition is None, this method returns normally.
Else, it throws TestCanceledException with the String
value of the Some, as well as the
String obtained by invoking toString on the
specified clue,
included in the TestCanceledException's detail message.

This form of assume is usually called in conjunction with an
implicit conversion to Equalizer, using a === comparison, as in: