Status

Non-blocking call that indicates whether the all the tests or nested suites fired off by the run method that returned the Status have completed. Because this is non-blocking, you can use this to poll the completion status.

Note: this method will not indicate whether a test has failed, suite has aborted, or an unreported exception has been installed. It just indicates whether the Status has completed or not by returning true or false.

Registers the passed callback function to be executed when this status completes.

If an unreported exception has been installed on this Status, the Try passed into the callback function will be a Failure containing that exception. Otherwise the Try will be a Success containing true if no tests failed or suites completed during the activity represented by this Status, else false.

You may register multiple callback functions, which on completion will be executed in an undefined order.

The callback functions registered with whenCompleted will be executed after the Status has completed. If the Status has already completed, functions passed to this method will be executed immediately by the calling thread before returning.

Any exception thrown by a callback function will be propagated back on the thread used to invoke the callback.

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

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.

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.Errors.

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.

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.