var util,
hasOwn = Object.prototype.hasOwnProperty,
- log = ( window.console && window.console.log )
- ? function () { return window.console.log.apply( window.console, arguments ); }
- : function () {};
+ log = ( window.console && window.console.log ) ?
+ function () { return window.console.log.apply( window.console, arguments ); } :
+ function () {};
// Simplified version of a few jQuery methods, except that they don't
// call other jQuery methods. Required to be able to run the CompletenessTest
/**
* CompletenessTest
- * @constructor
*
+ * @constructor
* @example
* var myTester = new CompletenessTest( myLib );
- * @param masterVariable {Object} The root variable that contains all object
+ * @param {Object} masterVariable The root variable that contains all object
* members. CompletenessTest will recursively traverse objects and keep track
* of all methods.
- * @param ignoreFn {Function} Optionally pass a function to filter out certain
+ * @param {Function} [ignoreFn] Optionally pass a function to filter out certain
* methods. Example: You may want to filter out instances of jQuery or some
* other constructor. Otherwise "missingTests" will include all methods that
* were not called from that instance.
} );
QUnit.done( function () {
+ var toolbar, testResults, cntTotal, cntCalled, cntMissing;
+
that.populateMissingTests();
log( 'CompletenessTest/populateMissingTests', that );
- var toolbar, testResults, cntTotal, cntCalled, cntMissing;
-
cntTotal = util.keys( that.injectionTracker ).length;
cntCalled = util.keys( that.methodCallTracker ).length;
cntMissing = util.keys( that.missingTests ).length;
elOutputWrapper.appendChild( elContainer );
util.each( style, function ( key, value ) {
- elOutputWrapper.style[key] = value;
+ elOutputWrapper.style[ key ] = value;
} );
return elOutputWrapper;
}
* Depending on the action it either injects our listener into the methods, or
* reads from our tracker and records which methods have not been called by the test suite.
*
- * @param currName {String|Null} Name of the given object member (Initially this is null).
- * @param currVar {mixed} The variable to check (initially an object,
+ * @param {Mixed} currObj The variable to check (initially an object,
* further down it could be anything).
- * @param masterVariable {Object} Throughout our interation, always keep track of the master/root.
+ * @param {string|null} currName Name of the given object member (Initially this is null).
+ * @param {Object} masterVariable Throughout our interation, always keep track of the master/root.
* Initially this is the same as currVar.
- * @param parentPathArray {Array} Array of names that indicate our breadcrumb path starting at
+ * @param {Array} parentPathArray Array of names that indicate our breadcrumb path starting at
* masterVariable. Not including currName.
*/
walkTheObject: function ( currObj, currName, masterVariable, parentPathArray ) {
if ( currName ) {
currPathArray.push( currName );
- currVal = currObj[currName];
+ currVal = currObj[ currName ];
} else {
currName = '(root)';
currVal = currObj;
// Hard ignores
if ( this.ignoreFn( currVal, this, currPathArray ) ) {
- return null;
+ return;
}
// Handle the lazy limit
this.lazyCounter++;
if ( this.lazyCounter > this.lazyLimit ) {
log( 'CompletenessTest.fn.walkTheObject> Limit reached: ' + this.lazyCounter, currPathArray );
- return null;
+ return;
}
// Functions
* was called during the test suite (as far as the tracker knows).
* If not it adds it to missingTests.
*
- * @param fnName {String}
- * @return {Boolean}
+ * @param {string} fnName
+ * @return {boolean}
*/
hasTest: function ( fnName ) {
if ( !( fnName in this.methodCallTracker ) ) {
- this.missingTests[fnName] = true;
+ this.missingTests[ fnName ] = true;
return false;
}
return true;
* Injects a function (such as a spy that updates methodCallTracker when
* it's called) inside another function.
*
- * @param masterVariable {Object}
- * @param objectPathArray {Array}
- * @param injectFn {Function}
+ * @param {Object} obj The object into which `injectFn` will be inserted
+ * @param {Array} key The key by which `injectFn` will be known in `obj`; if this already
+ * exists, a wrapper will first call `injectFn` and then the original `obj[key]` function.
+ * @param {Function} injectFn The function to insert
*/
injectCheck: function ( obj, key, injectFn ) {
var spy,
// Make the spy inherit from the original so that its static methods are also
// visible in the spy (e.g. when we inject a check into mw.log, mw.log.warn
// must remain accessible).
- // XXX: https://github.com/jshint/jshint/issues/2656
- /*jshint ignore:start */
- /*jshint proto:true */
spy.__proto__ = val;
- /*jshint ignore:end */
// Objects are by reference, members (unless objects) are not.
obj[ key ] = spy;
dépôts / lhc / web / wiklou.git / blobdiff