Helper class used by code generated by the assert
macro.
Helper class used by code generated by the assert
macro.
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:
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.
the boolean condition to assert
An objects whose toString
method returns a message to include in a failure report.
NullArgumentException
if message
is null
.
TestFailedException
if the condition is false
.
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:
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.
the boolean condition to assert
TestFailedException
if the condition is false
.
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.
the snippet of code that should compile
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
.
the snippet of code that should not type check
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.
the expected value
the actual value, which should equal the passed expected
value
TestFailedException
if the passed actual
value does not equal the passed expected
value.
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
.
the expected value
An object whose toString
method returns a message to include in a failure report.
the actual value, which should equal the passed expected
value
TestFailedException
if the passed actual
value does not equal the passed expected
value.
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.
the function value that should throw the expected exception
an implicit ClassTag
representing the type of the specified
type parameter.
the Succeeded
singleton, if an exception of the expected type is thrown
TestFailedException
if the passed function does not complete abruptly with an exception
that's an instance of the specified type.
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
.
the snippet of code that should not type check
Helper instance used by code generated by macro 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:
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.
the boolean condition to assume
An objects whose toString
method returns a message to include in a failure report.
NullArgumentException
if message
is null
.
TestCanceledException
if the condition is false
.
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:
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.
the boolean condition to assume
TestCanceledException
if the condition is false
.
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
.
a Throwable
that indicates the cause of the cancellation.
NullArgumentException
if cause
is null
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.
A message describing the failure.
A Throwable
that indicates the cause of the failure.
NullArgumentException
if message
or cause
is null
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.
A message describing the cancellation.
NullArgumentException
if message
is null
Throws TestCanceledException
to indicate a test was canceled.
Throws TestCanceledException
to indicate a test was canceled.
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
.
a Throwable
that indicates the cause of the failure.
NullArgumentException
if cause
is null
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.
A message describing the failure.
A Throwable
that indicates the cause of the failure.
NullArgumentException
if message
or cause
is null
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.
A message describing the failure.
NullArgumentException
if message
is null
Throws TestFailedException
to indicate a test failed.
Throws TestFailedException
to indicate a test failed.
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.
the function value that should throw the expected exception
an implicit ClassTag
representing the type of the specified
type parameter.
the intercepted exception, if it is of the expected type
TestFailedException
if the passed function does not complete abruptly with an exception
that's an instance of the specified type.
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.
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.
a block of code, which if it completes abruptly, should trigger a TestPendingException
TestPendingException
if the passed block of code completes abruptly with an Exception
or AssertionError
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.
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
NullArgumentException
if the passed clue
is null
Trap and return any thrown exception that would normally cause a ScalaTest test to fail, or create and return a new RuntimeException
indicating no exception is thrown.
Trap and return any thrown exception that would normally cause a ScalaTest test to fail, or create and return a new RuntimeException
indicating no exception is thrown.
This method is intended to be used in the Scala interpreter to eliminate large stack traces when trying out ScalaTest assertions and
matcher expressions. It is not intended to be used in regular test code. If you want to ensure that a bit of code throws an expected
exception, use intercept
, not trap
. Here's an example interpreter session without trap
:
scala> import org.scalatest._ import org.scalatest._ scala> import Matchers._ import Matchers._ scala> val x = 12 a: Int = 12 scala> x shouldEqual 13 org.scalatest.exceptions.TestFailedException: 12 did not equal 13 at org.scalatest.Assertions$class.newAssertionFailedException(Assertions.scala:449) at org.scalatest.Assertions$.newAssertionFailedException(Assertions.scala:1203) at org.scalatest.Assertions$AssertionsHelper.macroAssertTrue(Assertions.scala:417) at .<init>(<console>:15) at .<clinit>(<console>) at .<init>(<console>:7) at .<clinit>(<console>) at $print(<console>) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:731) at scala.tools.nsc.interpreter.IMain$Request.loadAndRun(IMain.scala:980) at scala.tools.nsc.interpreter.IMain.loadAndRunReq$1(IMain.scala:570) at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:601) at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:565) at scala.tools.nsc.interpreter.ILoop.reallyInterpret$1(ILoop.scala:745) at scala.tools.nsc.interpreter.ILoop.interpretStartingWith(ILoop.scala:790) at scala.tools.nsc.interpreter.ILoop.command(ILoop.scala:702) at scala.tools.nsc.interpreter.ILoop.processLine$1(ILoop.scala:566) at scala.tools.nsc.interpreter.ILoop.innerLoop$1(ILoop.scala:573) at scala.tools.nsc.interpreter.ILoop.loop(ILoop.scala:576) at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply$mcZ$sp(ILoop.scala:867) at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:822) at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:822) at scala.tools.nsc.util.ScalaClassLoader$.savingContextLoader(ScalaClassLoader.scala:135) at scala.tools.nsc.interpreter.ILoop.process(ILoop.scala:822) at scala.tools.nsc.MainGenericRunner.runTarget$1(MainGenericRunner.scala:83) at scala.tools.nsc.MainGenericRunner.process(MainGenericRunner.scala:96) at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:105) at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)
That's a pretty tall stack trace. Here's what it looks like when you use trap
:
scala> trap { x shouldEqual 13 } res1: Throwable = org.scalatest.exceptions.TestFailedException: 12 did not equal 13
Much less clutter. Bear in mind, however, that if no exception is thrown by the
passed block of code, the trap
method will create a new NormalResult
(a subclass of Throwable
made for this purpose only) and return that. If the result was the Unit
value, it
will simply say that no exception was thrown:
scala> trap { x shouldEqual 12 } res2: Throwable = No exception was thrown.
If the passed block of code results in a value other than Unit
, the NormalResult
's toString
will print the value:
scala> trap { "Dude!" } res3: Throwable = No exception was thrown. Instead, result was: "Dude!"
Although you can access the result value from the NormalResult
, its type is Any
and therefore not
very convenient to use. It is not intended that trap
be used in test code. The sole intended use case for trap
is decluttering
Scala interpreter sessions by eliminating stack traces when executing assertion and matcher expressions.
The trap method is no longer needed for demos in the REPL, which now abreviates stack traces, and will be removed in a future version of ScalaTest
Trait that contains ScalaTest's basic assertion methods.
You can use the assertions provided by this trait in any ScalaTest
Suite
, becauseSuite
mixes in this trait. This trait is designed to be used independently of anything else in ScalaTest, though, so you can mix it into anything. (You can alternatively import the methods defined in this trait. For details, see the documentation for theAssertions
companion object.In any Scala program, you can write assertions by invoking
assert
and passing in aBoolean
expression, such as:If the passed expression is
true
,assert
will return normally. Iffalse
, Scala'sassert
will complete abruptly with anAssertionError
. This behavior is provided by theassert
method defined in objectPredef
, whose members are implicitly imported into every Scala source file. ThisAssertions
trait defines anotherassert
method that hides the one inPredef
. It behaves the same, except that iffalse
is passed it throwsTestFailedException
instead ofAssertionError
. Why? Because unlikeAssertionError
,TestFailedException
carries information about exactly which item in the stack trace represents the line of test code that failed, which can help users more quickly find an offending line of code in a failing test. In addition, ScalaTest'sassert
provides better error messages than Scala'sassert
.If you pass the previous
Boolean
expression,left == right
toassert
in a ScalaTest test, a failure will be reported that, becauseassert
is implemented as a macro, includes reporting the left and right values. For example, given the same code as above but using ScalaTest assertions:The detail message in the thrown
TestFailedException
from thisassert
will be: "2 did not equal 1".ScalaTest's
assert
macro works by recognizing patterns in the AST of the expression passed toassert
and, for a finite set of common expressions, giving an error message that an equivalent ScalaTest matcher expression would give. Here are some examples, wherea
is 1,b
is 2,c
is 3,d
is 4,xs
isList(a, b, c)
, andnum
is 1.0:For expressions that are not recognized, the macro currently prints out a string representation of the (desugared) AST and adds
"was false"
. Here are some examples of error messages for unrecognized expressions:You can augment the standard error message by providing a
String
as a second argument toassert
, like this:Using this form of
assert
, the failure report will be more specific to your problem domain, thereby helping you debug the problem. ThisAssertions
trait also mixes in theTripleEquals
, which gives you a===
operator that allows you to customizeEquality
, perform equality checks with numericTolerance
, and enforce type constraints at compile time with sibling traitsTypeCheckedTripleEquals
andConversionCheckedTripleEquals
.Expected results
Although the
assert
macro provides a natural, readable extension to Scala'sassert
mechanism that provides good error messages, as the operands become lengthy, the code becomes less readable. In addition, the error messages generated for==
and===
comparisons don't distinguish between actual and expected values. The operands are just calledleft
andright
, because if one were namedexpected
and the otheractual
, it would be difficult for people to remember which was which. To help with these limitations of assertions,Suite
includes a method calledassertResult
that can be used as an alternative toassert
. To useassertResult
, you place the expected value in parentheses afterassertResult
, followed by curly braces containing code that should result in the expected value. For example:In this case, the expected value is
2
, and the code being tested isa - b
. This assertion will fail, and the detail message in theTestFailedException
will read, "Expected 2, but got 3."Forcing failures
If you just need the test to fail, you can write:
Or, if you want the test to fail with a message, write:
fail("I've got a bad feeling about this")
Achieving success
In async style tests, you must end your test body with either
Future[Assertion]
orAssertion
. ScalaTest's assertions (including matcher expressions) have result typeAssertion
, so ending with an assertion will satisfy the compiler. If a test body or function body passed toFuture.map
does not end with typeAssertion
, however, you can fix the type error by placingsucceed
at the end of the test or function body:succeed // Has type Assertion
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. You can do this in the JUnit 3 style, like this:
If
charAt
throwsIndexOutOfBoundsException
as expected, control will transfer to the catch case, which does nothing. If, however,charAt
fails to throw an exception, the next statement,fail()
, will be run. Thefail
method always completes abruptly with aTestFailedException
, thereby signaling a failed test.To make this common use case easier to express and read, ScalaTest provides two methods:
assertThrows
andintercept
. Here's how you useassertThrows
:This code behaves much like the previous example. If
charAt
throws an instance ofIndexOutOfBoundsException
,assertThrows
will returnSucceeded
. But ifcharAt
completes normally, or throws a different exception,assertThrows
will complete abruptly with aTestFailedException
.The
intercept
method behaves the same asassertThrows
, except that instead of returningSucceeded
,intercept
returns the caught exception so that you can inspect it further if you wish. For example, you may need to ensure that data contained inside the exception have expected values. Here's an example:Checking that a snippet of code does or 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's
Assertions
trait includes the following syntax for that purpose:assertDoesNotCompile("val a: String = 1")
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:
assertTypeError("val a: String = 1")
Note that the
assertTypeError
call 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 thrownTestFailedException
.If you want to state that a snippet of code does compile, you can make that more obvious with:
assertCompiles("val a: Int = 1")
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.
Assumptions
Trait
Assertions
also provides methods that allow you to cancel a test. You would cancel a test if a resource required by the test was unavailable. For example, if a test requires an external database to be online, and it isn't, the test could be canceled to indicate it was unable to run because of the missing database. Such a test assumes a database is available, and you can use theassume
method to indicate this at the beginning of the test, like this:For each overloaded
assert
method, traitAssertions
provides an overloadedassume
method with an identical signature and behavior, except theassume
methods throwTestCanceledException
whereas theassert
methods throwTestFailedException
. As withassert
,assume
hides a Scala method inPredef
that performs a similar function, but throwsAssertionError
. And just as you can withassert
, you will get an error message extracted by a macro from the AST passed toassume
, and can optionally provide a clue string to augment this error message. Here are some examples:Forcing cancelations
For each overloaded
fail
method, there's a correspondingcancel
method with an identical signature and behavior, except thecancel
methods throwTestCanceledException
whereas thefail
methods throwTestFailedException
. Thus if you just need to cancel a test, you can write:If you want to cancel the test with a message, just place the message in the parentheses:
cancel("Can't run the test because no internet connection was found")
Getting a clue
If you want more information that is provided by default by the methods if this trait, you can supply a "clue" string in one of several ways. The extra information (or "clues") you provide will be included in the detail message of the thrown exception. Both
assert
andassertResult
provide a way for a clue to be included directly,intercept
does not. Here's an example of clues provided directly inassert
:and in
assertResult
:The exceptions thrown by the previous two statements will include the clue string,
"this is a clue"
, in the exception's detail message. To get the same clue in the detail message of an exception thrown by a failedintercept
call requires usingwithClue
:The
withClue
method will only prepend the clue string to the detail message of exception types that mix in theModifiableMessage
trait. See the documentation forModifiableMessage
for more information. If you wish to place a clue string after a block of code, see the documentation forAppendedClues
.Note: ScalaTest's
assertTypeError
construct is in part inspired by theillTyped
macro of shapeless.