[qunit] use generics for strictEqual and deepEqual

types/qunit/index.d.ts

@@ -7,14 +7,14 @@
 interface Assert {
     /**
      * Instruct QUnit to wait for an asynchronous operation.
-     * 
+     *
      * The callback returned from `assert.async()` will throw an Error if it is
      * invoked more than once (or more often than the accepted call count, if
      * provided).
      *
      * This replaces functionality previously provided by `QUnit.stop()` and
      * `QUnit.start()`.
-     * 
+     *
      * @param {number} [acceptCallCount=1] Number of expected callbacks before the test is done.
      */
     async(acceptCallCount?: number): () => void;
@@ -22,179 +22,179 @@ interface Assert {
     /**
      * A deep recursive comparison, working on primitive types, arrays, objects,
      * regular expressions, dates and functions.
-     * 
+     *
      * The `deepEqual()` assertion can be used just like `equal()` when comparing
      * the value of objects, such that `{ key: value }` is equal to
      * `{ key: value }`. For non-scalar values, identity will be disregarded by
      * deepEqual.
-     * 
+     *
      * `notDeepEqual()` can be used to explicitly test deep, strict inequality.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparision value
-     * @param {string} [message] A short description of the assertion 
+     * @param {string} [message] A short description of the assertion
      */
-    deepEqual(actual: any, expected: any, message?: string): void;
-    
+    deepEqual<T>(actual: T, expected: T, message?: string): void;
+
     /**
      * A non-strict comparison, roughly equivalent to JUnit's assertEquals.
-     * 
+     *
      * The `equal` assertion uses the simple comparison operator (`==`) to
      * compare the actual and expected arguments. When they are equal, the
      * assertion passes; otherwise, it fails. When it fails, both actual and
      * expected values are displayed in the test result, in addition to a given
      * message.
-     * 
+     *
      *  `notEqual()` can be used to explicitly test inequality.
-     * 
+     *
      * `strictEqual()` can be used to test strict equality.
-     * 
+     *
      * @param actual Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
     equal(actual: any, expected: any, message?: string): void;
-    
+
     /**
      * Specify how many assertions are expected to run within a test.
-     * 
+     *
      * To ensure that an explicit number of assertions are run within any test,
      * use `assert.expect( number )` to register an expected count. If the
      * number of assertions run does not match the expected count, the test will
      * fail.
-     * 
+     *
      * @param {number} amount Number of assertions in this test.
      */
     expect(amount: number): void;
-    
+
     /**
      * An inverted deep recursive comparison, working on primitive types,
      * arrays, objects, regular expressions, dates and functions.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
     notDeepEqual(actual: any, expected: any, message?: string): void;
-    
+
     /**
      * A non-strict comparison, checking for inequality.
-     * 
+     *
      * The `notEqual` assertion uses the simple inverted comparison operator
      * (`!=`) to compare the actual and expected arguments. When they aren't
      * equal, the assertion passes; otherwise, it fails. When it fails, both
      * actual and expected values are displayed in the test result, in addition
      * to a given message.
-     * 
+     *
      * `equal()` can be used to test equality.
-     * 
+     *
      * `notStrictEqual()` can be used to test strict inequality.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
     notEqual(actual: any, expected: any, message?: string): void;
-    
+
     /**
      * A boolean check, inverse of `ok()` and CommonJS's `assert.ok()`, and
      * equivalent to JUnit's `assertFalse()`. Passes if the first argument is
      * falsy.
-     * 
+     *
      * `notOk()` requires just one argument. If the argument evaluates to false,
      * the assertion passes; otherwise, it fails. If a second message argument
      * is provided, it will be displayed in place of the result.
-     * 
+     *
      * @param state Expression being tested
      * @param {string} [message] A short description of the assertion
      */
     notOk(state: any, message?: string): void;
-    
+
     /**
      * A strict comparison of an object's own properties, checking for inequality.
-     * 
+     *
      * The `notPropEqual` assertion uses the strict inverted comparison operator
      * (`!==`) to compare the actual and expected arguments as Objects regarding
      * only their properties but not their constructors.
-     * 
+     *
      * When they aren't equal, the assertion passes; otherwise, it fails. When
      * it fails, both actual and expected values are displayed in the test
      * result, in addition to a given message.
-     * 
+     *
      * `equal()` can be used to test equality.
-     * 
+     *
      * `propEqual()` can be used to test strict equality of an Object properties.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
     notPropEqual(actual: any, expected: any, message?: string): void;
-    
+
     /**
      * A strict comparison, checking for inequality.
-     * 
+     *
      * The `notStrictEqual` assertion uses the strict inverted comparison
      * operator (`!==`) to compare the actual and expected arguments. When they
      * aren't equal, the assertion passes; otherwise, it fails. When it fails,
      * both actual and expected values are displayed in the test result, in
      * addition to a given message.
-     * 
+     *
      * `equal()` can be used to test equality.
-     * 
+     *
      * `strictEqual()` can be used to test strict equality.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
     notStrictEqual(actual: any, expected: any, message?: string): void;
-    
+
     /**
      * A boolean check, equivalent to CommonJS's assert.ok() and JUnit's
      * assertTrue(). Passes if the first argument is truthy.
-     * 
+     *
      * The most basic assertion in QUnit, ok() requires just one argument. If
      * the argument evaluates to true, the assertion passes; otherwise, it
      * fails. If a second message argument is provided, it will be displayed in
      * place of the result.
-     * 
+     *
      * @param state Expression being tested
      * @param {string} message A short description of the assertion
      */
     ok(state: any, message?: string): void;
-    
+
     /**
      * A strict type and value comparison of an object's own properties.
-     * 
+     *
      * The `propEqual()` assertion provides strictly (`===`) comparison of
      * Object properties. Unlike `deepEqual()`, this assertion can be used to
      * compare two objects made with different constructors and prototype.
-     * 
+     *
      * `strictEqual()` can be used to test strict equality.
-     * 
+     *
      * `notPropEqual()` can be used to explicitly test strict inequality of
      * Object properties.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
     propEqual(actual: any, expected: any, message?: string): void;
-    
+
     /**
      * Report the result of a custom assertion
-     * 
+     *
      * Some test suites may need to express an expectation that is not defined
      * by any of QUnit's built-in assertions. This need may be met by
      * encapsulating the expectation in a JavaScript function which returns a
      * `Boolean` value representing the result; this value can then be passed
      * into QUnit's `ok` assertion.
-     * 
+     *
      * A more readable solution would involve defining a custom assertion. If
      * the expectation function invokes `pushResult`, QUnit will be notified of
      * the result and report it accordingly.
-     * 
+     *
      * @param assertionResult The assertion result
      */
     pushResult(assertResult: {
@@ -203,31 +203,31 @@ interface Assert {
         expected: any;
         message: string;
     }): void;
-    
+
     /**
      * A strict type and value comparison.
-     * 
+     *
      * The `strictEqual()` assertion provides the most rigid comparison of type
      * and value with the strict equality operator (`===`).
-     * 
+     *
      * `equal()` can be used to test non-strict equality.
-     * 
+     *
      * `notStrictEqual()` can be used to explicitly test strict inequality.
-     * 
+     *
      * @param actual Object or Expression being tested
      * @param expected Known comparison value
      * @param {string} [message] A short description of the assertion
      */
-    strictEqual(actual: any, expected: any, message?: string): void;
-    
+    strictEqual<T>(actual: T, expected: T, message?: string): void;
+
     /**
      * Test if a callback throws an exception, and optionally compare the thrown
      * error.
-     * 
+     *
      * When testing code that is expected to throw an exception based on a
      * specific set of circumstances, use assert.throws() to catch the error
      * object for testing and comparison.
-     * 
+     *
      * In very few environments, like Closure Compiler, throws is considered a
      * reserved word and will cause an error. For that case, an alias is bundled
      * called `raises`. It has the same signature and behaviour, just a
@@ -238,30 +238,30 @@ interface Assert {
 
     /**
      * A marker for progress in a given test.
-     * 
-     * The `step()` assertion registers a passing assertion with a provided message. This makes 
-     * it easy to check that specific portions of code are being executed, especially in 
-     * asynchronous test cases and when used with `verifySteps()`. 
-     * 
+     *
+     * The `step()` assertion registers a passing assertion with a provided message. This makes
+     * it easy to check that specific portions of code are being executed, especially in
+     * asynchronous test cases and when used with `verifySteps()`.
+     *
      * Together with the `verifySteps()` method, `step()` assertions give you an easy way
      * to verify both the count and order of code execution.
-     * 
+     *
      * @param message Message to display for the step
      */
     step(message: string): void;
 
     /**
      * A helper assertion to verify the order and number of steps in a test.
-     * 
+     *
      * The assert.verifySteps() assertion compares a given array of string values (representing steps)
      * with the order and values of previous step() calls. This assertion is helpful for verifying
      * the order and count of portions of code paths, especially asynchronous ones.
-     * 
+     *
      * @param steps Array of strings representing steps to verify
      * @param message A short description of the assertion
      */
     verifySteps(steps: string[], message?: string): void;
- 
+
 }
 
 interface Config {
@@ -296,7 +296,7 @@ interface Hooks {
     /**
      * Runs after the last test. If additional tests are defined after the
      * module's queue has emptied, it will not run this hook again.
-     */    
+     */
     after?: (assert: Assert) => void;
 
     /**
@@ -320,7 +320,7 @@ interface NestedHooks {
     /**
      * Runs after the last test. If additional tests are defined after the
      * module's queue has emptied, it will not run this hook again.
-     */    
+     */
     after: (fn: (assert: Assert) => void) => void;
 
     /**
@@ -337,7 +337,7 @@ interface NestedHooks {
      * Runs before each test.
      */
     beforeEach: (fn: (assert: Assert) => void) => void;
-    
+
 }
 
 declare namespace QUnit {
@@ -373,30 +373,30 @@ declare namespace QUnit {
 }
 
 interface QUnit {
-    
+
     /**
      * Namespace for QUnit assertions
-     * 
+     *
      * QUnit's built-in assertions are defined on the `QUnit.assert` object. An
      * instance of this object is passed as the only argument to the `QUnit.test`
      * function callback.
-     * 
+     *
      * This object has properties for each of QUnit's built-in assertion methods.
      */
     assert: Assert;
 
     /**
      * Register a callback to fire whenever the test suite begins.
-     * 
+     *
      * `QUnit.begin()` is called once before running any tests.
-     * 
+     *
      * @callback callback Callback to execute.
      */
     begin(callback: (details: QUnit.BeginDetails) => void): void;
 
     /**
      * Configuration for QUnit
-     * 
+     *
      * QUnit has a bunch of internal configuration defaults, some of which are
      * useful to override. Check the description for each option for details.
      */
@@ -404,23 +404,23 @@ interface QUnit {
 
     /**
      * Register a callback to fire whenever the test suite ends.
-     * 
+     *
      * @param callback Callback to execute
      */
     done(callback: (details: QUnit.DoneDetails) => void): void;
 
     /**
      * Advanced and extensible data dumping for JavaScript.
-     * 
+     *
      * This method does string serialization by parsing data structures and
      * objects. It parses DOM elements to a string representation of their outer
      * HTML. By default, nested structures will be displayed up to five levels
      * deep. Anything beyond that is replaced by `[object Object]` and
      * `[object Array]` placeholders.
-     * 
+     *
      * If you need more or less output, change the value of `QUnit.dump.maxDepth`,
      * representing how deep the elements should be parsed.
-     * 
+     *
      * Note: This method used to be in QUnit.jsDump, which was changed to
      * QUnit.dump. The old property will be removed in QUnit 3.0.
      */
@@ -431,12 +431,12 @@ interface QUnit {
 
     /**
      * Copy the properties defined by the `mixin` object into the `target` object.
-     * 
+     *
      * This method will modify the `target` object to contain the "own" properties
      * defined by the `mixin`. If the `mixin` object specifies the value of any
      * attribute as undefined, this property will instead be removed from the
      * `target` object.
-     * 
+     *
      * @param target An object whose properties are to be modified
      * @param mixin An object describing which properties should be modified
      */
@@ -444,12 +444,12 @@ interface QUnit {
 
     /**
      * Register a callback to fire whenever an assertion completes.
-     * 
+     *
      * This is one of several callbacks QUnit provides. Its intended for
      * integration scenarios like PhantomJS or Jenkins. The properties of the
      * details argument are listed below as options.
-     * 
-     * @param callback Callback to execute 
+     *
+     * @param callback Callback to execute
      */
     log(callback: (details: QUnit.LogDetails) => void): void;
 
@@ -457,36 +457,36 @@ interface QUnit {
      * Group related tests under a single label.
      *
      * You can use the module name to organize, select, and filter tests to run.
-     * 
+     *
      * All tests inside a module callback function will be grouped into that
      * module. The test names will all be preceded by the module name in the
      * test results. Other modules can be nested inside this callback function,
      * where their tests' names will be labeled by their names recursively
      * prefixed by their parent modules.
-     * 
+     *
      * If `QUnit.module` is defined without a `nested` callback argument, all
      * subsequently defined tests will be grouped into the module until another
      * module is defined.
-     * 
+     *
      * Modules with test group functions allow you to define nested modules, and
      * QUnit will run tests on the parent module before going deep on the nested
      * ones, even if they're declared first. Additionally, any hook callbacks on
      * a parent module will wrap the hooks on a nested module. In other words,
      * `before` and `beforeEach` callbacks will form a queue while the
      * `afterEach` and `after` callbacks will form a stack.
-     * 
+     *
      * You can specify code to run before and after tests using the hooks
      * argument, and also to create properties that will be shared on the
      * testing context. Any additional properties on the `hooks` object will be
      * added to that context. The `hooks` argument is still optional if you call
      * `QUnit.module` with a callback argument.
-     * 
+     *
      * The module's callback is invoked with the test environment as its `this`
      * context, with the environment's properties copied to the module's tests,
      * hooks, and nested modules. Note that changes on tests' `this` are not
      * preserved between sibling tests, where `this` will be reset to the initial
      * value for each test.
-     *  
+     *
      * @param {string} name Label for this group of tests
      * @param hookds Callbacks to run during test execution
      * @param nested A callback with grouped tests and nested modules to run under the current module label
@@ -496,31 +496,31 @@ interface QUnit {
 
     /**
      * Register a callback to fire whenever a module ends.
-     * 
+     *
      * @param callback Callback to execute
      */
     moduleDone(callback: (details: QUnit.ModuleDoneDetails) => void): void;
 
     /**
      * Register a callback to fire whenever a module begins.
-     * 
+     *
      * @param callback Callback to execute
      */
     moduleStart(callback: (details: QUnit.ModuleStartDetails) => void): void;
 
     /**
      * Adds a test to exclusively run, preventing all other tests from running.
-     * 
+     *
      * Use this method to focus your test suite on a specific test. QUnit.only
      * will cause any other tests in your suite to be ignored.
-     * 
+     *
      * Note, that if more than one QUnit.only is present only the first instance
      * will run.
-     * 
+     *
      * This is an alternative to filtering tests to run in the HTML reporter. It
      * is especially useful when you use a console reporter or in a codebase
      * with a large set of long running tests.
-     * 
+     *
      * @param {string} name Title of unit being tested
      * @param callback Function to close over assertions
      */
@@ -528,48 +528,48 @@ interface QUnit {
 
     /**
      * DEPRECATED: Report the result of a custom assertion.
-     * 
+     *
      * This method is deprecated and it's recommended to use pushResult on its
      * direct reference in the assertion context.
-     * 
+     *
      * QUnit.push reflects to the current running test, and it may leak
      * assertions in asynchronous mode. Checkout assert.pushResult() to set a
      * proper custom assertion.
-     * 
+     *
      * Invoking QUnit.push allows to create a readable expectation that is not
      * defined by any of QUnit's built-in assertions.
-     * 
+     *
      * @deprecated
      */
     push(result: boolean, actual: any, expected: any, message: string): void;
 
     /**
      * Adds a test like object to be skipped.
-     * 
+     *
      * Use this method to replace QUnit.test() instead of commenting out entire
      * tests.
-     * 
+     *
      * This test's prototype will be listed on the suite as a skipped test,
      * ignoring the callback argument and the respective global and module's
      * hooks.
-     * 
+     *
      * @param {string} Title of unit being tested
      */
     skip(name: string, callback?: (assert: Assert) => void): void;
 
     /**
      * Returns a single line string representing the stacktrace (call stack).
-     * 
+     *
      * This method returns a single line string representing the stacktrace from
      * where it was called. According to its offset argument, `QUnit.stack()` will
      * return the correspondent line from the call stack.
-     * 
+     *
      * The default `offset` is `0` and will return the current location where it
      * was called.
-     * 
+     *
      * Not all browsers support retrieving stracktraces. In those, `QUnit.stack()`
      * will return undefined.
-     * 
+     *
      * @param {number} offset Set the stacktrace line offset.
      */
     stack(offset?: number): string;
@@ -577,10 +577,10 @@ interface QUnit {
     /**
      * `QUnit.start()` must be used to start a test run that has
      * `QUnit.config.autostart` set to `false`.
-     * 
+     *
      * This method was previously used to control async tests on text contexts
      * along with QUnit.stop. For asynchronous tests, use assert.async instead.
-     * 
+     *
      * When your async test has multiple exit points, call `QUnit.start()` for the
      * corresponding number of `QUnit.stop()` increments.
      */
@@ -588,16 +588,16 @@ interface QUnit {
 
     /**
      * Add a test to run.
-     * 
+     *
      * Add a test to run using `QUnit.test()`.
-     * 
+     *
      * The `assert` argument to the callback contains all of QUnit's assertion
      * methods. Use this argument to call your test assertions.
      *
      * `QUnit.test()` can automatically handle the asynchronous resolution of a
      * Promise on your behalf if you return a thenable Promise as the result of
      * your callback function.
-     * 
+     *
      * @param {string} Title of unit being tested
      * @param callback Function to close over assertions
      */
@@ -605,7 +605,7 @@ interface QUnit {
 
     /**
      * Register a callback to fire whenever a test ends.
-     * 
+     *
      * @param callback Callback to execute
      */
     testDone(callback: (details: {
@@ -619,7 +619,7 @@ interface QUnit {
 
     /**
      * Register a callback to fire whenever a test begins.
-     * 
+     *
      * @param callback Callback to execute
      */
     testStart(callback: (details: QUnit.TestStartDetails) => void): void;
@@ -649,7 +649,7 @@ interface QUnit {
 
     /**
      * Are the test running from the server or not.
-     */ 
+     */
     isLocal: boolean;
 
     /**