goog.testing.MockClock

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added. If a callback is added to an already disposed Disposable, it will be called immediately.

Disposes of the object and its resources.

Performs appropriate cleanup. See description of goog.disposable.IDisposable for examples. Classes that extend goog.Disposable should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass' disposeInternal method. Everywhere else the public dispose method must be used. For example:

 mypackage.MyClass = function() {
 mypackage.MyClass.base(this, 'constructor');
     // Constructor logic specific to MyClass.
     ...
   };
   goog.inherits(mypackage.MyClass, goog.Disposable);

   mypackage.MyClass.prototype.disposeInternal = function() {
     // Dispose logic specific to MyClass.
     ...
     // Call superclass's disposeInternal at the end of the subclass's, like
     // in C++, to avoid hard-to-catch issues.
     mypackage.MyClass.base(this, 'disposeInternal');
   };
 

Instantly adjusts the clock's current time to a new timestamp. Unlike tick(), this method skips over the intervening time, so that setInterval() calls or recurring setTimeout()s will only run once.

This mimics the behavior of setting the system clock, rather than waiting for time to pass.

CAUTION: This is an advanced feature. Use this method to set the clock to be a specific date, which is much faster than calling tick() with a large value. This lets you test code against arbitrary dates.

MOE:begin_strip See go/mockclock-time-travel for how & why to use this method. MOE:end_strip

Installs the MockClock by overriding the global object's implementation of setTimeout, setInterval, clearTimeout and clearInterval.

Whether the MockClock is configured to run synchronously.

This allows MockClock consumers to decide whether to tick synchronously or asynchronously.

Associates a disposable object with this object so that they will be disposed together.

Resets the MockClock, removing all timeouts that are scheduled and resets the fake timer count.

Sets the amount of time between when a timeout is scheduled to fire and when it actually fires.

Increments the MockClock's time by a given number of milliseconds, running any functions that are now overdue.

Increments the MockClock's time by a given number of milliseconds, running any functions that are now overdue.

Asynchronously increments the MockClock's time by a given number of milliseconds, returning the settled promise value.

Takes a promise and then ticks the mock clock. If the promise successfully resolves, returns the value produced by the promise. If the promise is rejected, it throws the rejection as an exception. If the promise is not resolved at all, throws an exception. Also ticks the general clock by the specified amount. Only works with goog.Thenable, hence goog.Promise. Does NOT work with native browser promises.

Removes the MockClock's hooks into the global object's functions and revert to their original values.

Unmocks the Date.now() function for tests that aren't expecting it to be mocked. See b/141619890.

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.

Creates an async-only MockClock that can only be ticked asynchronously.

Async-only MockClocks rely on native Promise resolution instead of patching async run behavior to force GoogPromise to resolve synchronously. As a result, async MockClocks must be ticked with tickAsync() instead of tick().

Async-only MockClocks will always use the default async scheduler and will never reset the async queue when uninstalled.

Default wait timeout for mocking requestAnimationFrame (in milliseconds).

ID to use for next timeout. Timeout IDs must never be reused, even across MockClock instances.