goog.testing.ContinuationTestCase

Adds a new test to the test case.

Adds a callback function that should be executed when the tests have completed.

Creates and adds a new test.

Convenience function to make syntax less awkward when not using automatic test discovery.

Adds any functions defined on the global object that correspond to lifecycle events for the test case. Overrides setUp, tearDown, setUpPage, tearDownPage, runTests, and shouldRunTests if they are defined on global object.

Adds any functions defined in the global scope that are prefixed with "test" to the test case.

Clears a timeout created by this.timeout().

Creates a goog.testing.TestCase.Test from an auto-discovered function.

Cycles through the tests, yielding asynchronously if the execution time exceeds #maxRunTime. In particular, there is no guarantee that the test case has finished execution once this method has returned. To be notified when the test case has finished execution, use #addCompletedCallback or #runTestsReturningPromise.

Handles a test that failed.

Handles a test that was skipped.

Handles a test that passed.

Executes the tests, yielding asynchronously if execution time exceeds maxRunTime. There is no guarantee that the test case has finished once this method has returned. To be notified when the test case has finished, use #addCompletedCallback or #runTestsReturningPromise.

Finalizes the test case, called when the tests have finished executing.

Returns the number of tests actually run in the test case, i.e. subtracting any which are skipped.

Returns the number of tests contained in the test case.

Returns the current test or null.

Gets list of objects that potentially contain test cases. For IE 8 and below, this is the global "this" (for properties set directly on the global this or window) and the RuntimeObject (for global variables and functions). For all other browsers, the array simply contains the global this.

Returns the number of script files that were loaded in order to run the test.

Returns a string detailing the results from the test.

Returns the test results.

Returns the amount of time it took for the test to run.

Returns the test results object: a map from test names to a list of test failures (if any exist).

Gets the tests.

Closes the group of the upcoming logs

Groups the upcoming logs in the same log group

Call this from setUpPage() to prevent any Content Security Policy violations that may have occurred during page load from being reported as errors .

Removes the specified exception from being tracked. This only needs to be called for internal functions that intentionally catch an exception, such as #assertThrowsJsUnitException.

Logs an object to the console, if available.

Checks to see if the test should be marked as failed before it is run.

If there was an error in setUpPage, we treat that as a failure for all tests and mark them all as having failed.

Returns the current test and increments the pointer.

Toggles recording of Content Security Policy violations. Call this with false during tests, setUpPage, setUp, and tearDown functions to prevent CSP violations occurring while the function is executing from being reported as errors. Reporting will be reset upon execution of the next test function.

Makes note of an exception arising from an assertion, and then throws it. If the test otherwise passes (i.e., because something else caught the exception on its way to the test framework), it will be forced to fail.

Records and logs an error from or related to a test.

Records an error that fails the current test, without throwing it.

Use this function to implement expect()-style assertion libraries that fail a test without breaking execution (so you can see further failures). Do not use this from normal test code.

Please contact js-core-libraries-team@ before using this method. If it grows popular, we may add an expect() API to Closure.

NOTE: If there is no active TestCase, you must throw an error.

Resets the test case pointer, so that next returns the first test.

Executes each of the tests, yielding asynchronously if execution time exceeds #maxRunTime. There is no guarantee that the test case has finished execution once this method has returned. To be notified when the test case has finished execution, use #addCompletedCallback or #runTestsReturningPromise.

Overridable by the individual test case. This allows test cases to defer when the test is actually started. If overridden, finalize must be called by the test to indicate it has finished.

Executes each of the tests, returning a promise that resolves with the test results once they are done running.

Saves a message to the result set.

Extracts any functions defined on 'obj' that correspond to page lifecycle events (setUpPage, tearDownPage, runTests, shouldRunTests) and add them to on this test case.

Sets the tests.

Gets called before every goog.testing.TestCase.Test is been executed. Can be overridden to add set up functionality to each test.

Gets called before any tests are executed. Can be overridden to set up the environment for the whole test case.

Can be overridden in test classes to indicate whether the tests in a case should be run in that particular situation. For example, this could be used to stop tests running in a particular browser, where browser support for the class under test was absent.

Gets called after every goog.testing.TestCase.Test has been executed. Can be overridden to add tear down functionality to each test.

Gets called after all tests have been executed. Can be overridden to tear down the entire test case.

Calls a function after a delay, using the protected timeout.

Configures the TestCase to use goog.Promise when waiting for methods that return Thenables.

Configures the TestCase to use native Promises when waiting for methods that return Thenables.

Creates a new test step which will run once a condition becomes true. The condition will be polled at a user-specified interval until it becomes true, or until a maximum timeout is reached.

Creates a new test step that will run after an event has fired. If the event does not fire within a reasonable timeout, the test will fail.

Creates a new test step that will run after a user-specified timeout. No guarantee is made on the execution order of the continuation, except for those provided by each browser's window.setTimeout. In particular, if two continuations are registered at the same time with very small delta for their durations, this class can not guarantee that the continuation with the smaller duration will be executed first.

No information.

Exception object that was detected before a test runs.

The order to run the auto-discovered tests in.

The maximum time in milliseconds a promise returned from a test function may remain pending before the test fails due to timeout.

Object used to encapsulate the test results.

Whether the test case is running.

Whether the test case has ever tried to execute.

The default maximum time to wait for a single test step in milliseconds.