goog.testing.AsyncTestCase

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().

Continue with the next step in the test cycle.

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

Starts the tests.

Handles an exception thrown by a test.

Handles a test that failed.

Handles a test that was skipped.

Handles a test that passed.

Enables verbose logging of what is happening inside of the AsyncTestCase.

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.

The current step name.

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.

Sets up the test page and then waits until the test case has been marked as ready before executing the tests.

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.

Signals once to continue with the test. If this is the last signal that the test was waiting on, call continueTesting.

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.

Informs the testcase not to continue to the next step in the test cycle until continueTesting is called.

Informs the testcase not to continue to the next step in the test cycle until signal is called the specified number of times. Within a test, this function behaves additively if called multiple times; the number of signals to wait for will be the sum of all expected number of signals this function was called with.

The currently active test.

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.

How long to wait for a single step of a test to complete in milliseconds. A step starts when a call to waitForAsync() is made.

How long to wait after a failed test before moving onto the next one. The purpose of this is to allow any pending async callbacks from the failing test to finish up and not cause the next test to fail.

Preferred way of creating an AsyncTestCase. Creates one and initializes it with the G_testRunner.