Always returns true
.
Registers a Status
-producing by-name function to execute after this
Status
completes, returning a Status
that mirrors the Status
returned by the by-name.
Registers a Status
-producing by-name function to execute after this
Status
completes, returning a Status
that mirrors the Status
returned by the by-name.
This method is used by async styles to ensure that by default, each subsequent test in an async-style
suite begins execution only after the previous test has completed. This method is not used if
ParallelTestExection
is mixed into an async style. Instead, tests are allowed to begin
execution concurrently.
The Status
returned by this method will completes when the status produced by the
Status
produced by the passed-by name completes. The returned Status
will complete with the same succeeds
and unreportedException
values.
But unlike the Status
produced by the by-name, the returned Status
will
be available immediately.
If a by-name function passed to this method
a Status
that represents the status of executing the by-name function passed to this method.
Converts this Status
to a Future[Boolean]
where Success(true)
means
no tests failed and suites aborted, Success(false)
, means at least one test failed or one
suite aborted and those events were reported via the Reporter
, Failure(ex)
means
a suite aborted but the exception, ex
, was not reported to the Reporter
.
Converts this Status
to a Future[Boolean]
where Success(true)
means
no tests failed and suites aborted, Success(false)
, means at least one test failed or one
suite aborted and those events were reported via the Reporter
, Failure(ex)
means
a suite aborted but the exception, ex
, was not reported to the Reporter
.
An exception that was not reported by the activity represented by this Status
.
An exception that was not reported by the activity represented by this Status
.
When a test executes, "non-test-fatal" thrown exceptions are reported by the events
fired to the reporter. A TestPendingException
is reported via a
TestPending
event. A TestCanceledException
is reported via a
TestCanceled
event. Any other non-test-fatal exceptions, including
TestFailedException
will be reported via a
TestFailed
event.
Test-fatal exceptions indicate critical
problems, such as OutOfMemoryError
, that instead of being reported via a test completion event
should instead cause the entire suite to abort. In synchronous testing styles, this exception will be allowed
to just propagate up the call stack. But in async styles, the thread or threads executing the test will often
be taken from the async suite's execution context. Instead of propagating these test-fatal exceptions up
the call stack, they will be installed as an "unreported exception" in the test's Status
.
They are "unreported" because no test completion event will be fired to report them. For more explanation and
a list of test-fatal exception types, see Treatment of java.lang.Error
s.
Another way for an unreported exception to occur is if an exception of any type is thrown outside of the
body of an actual test. For example, traits BeforeAndAfter
, BeforeAndAfterEach
,
and BeforeAndAfterEachTestData
execute code before and after tests. Traits
BeforeAndAfterAll
and BeforeAndAfterAllConfigMap
execute code before
and after all tests and nested suites. If any "before" or "after"
code completes abruptly with an exception (of any type, not just test-fatal types) on a thread taken
from an async suite's execution context, this exception will
installed as an unreportedException
of the relevant Status
. TODO: Is that true. Tests will tell.
In addition, ScalaTest Suite
exposes four "run" lifecycle methods--run
,
runNestedSuites
, runTests
, and runTest
--that users can override to customize
the framework. If a "run" lifecycle methods completes abruptly with an exception, that exception occurs outside
the context of a test body. As a result, such exceptions will be
installed as an unreportedException
of the relevant Status
.
The toFuture
method on Status
returns a Future[Boolean]
. If the Future
succeeds with the Boolean
value of true
, that indicates no tests failed and no suites aborted
during the activity represented
by this Status
. If a test failed or suite aborted, and that event was reported by a fired ScalaTest
Event
, the
Future
will succeed with the value false
. If an unreported exception has been installed
on the Status
, however, the Future
will fail with that exception.
Executes the passed function immediately on the calling thread.
Executes the passed function immediately on the calling thread.
Registers a by-name function (producing an optional exception) to execute
after this Status
completes.
Registers a by-name function (producing an optional exception) to execute
after this Status
completes.
This method is used by traits BeforeAndAfter
,
BeforeAndAfterAllConfigMap
, BeforeAndAfterEach
,
and BeforeAndAfterEachTestData
to ensure "after" code is executed after
the relevant test completes, or the case of BeforeAndAfterAll
, tests and nested suites complete.
BeforeAndAfterAll
,
So what's wierd about this one is that I have it returning Option[Throwable], because that was what I had in hand, but I need to specify what happens if the method throws an exception anyway, so maybe it should be thrown instead of optionally returned. Also, what happens if it is a test-aborting exception. I think what should happen is it shows up in the status as an unreportedException, but wrapped in an ExecutionException. This would simplify the thing. Then also what happens if it is that, is the inner exception, the real one is allowed to propagate up the call stack.