From 14eba98c8f189c2e6a36e640bedce2ce6db34493 Mon Sep 17 00:00:00 2001
From: Oleg Gaidarenko <markelog@gmail.com>
Date: Tue, 22 Dec 2015 18:51:04 +0300
Subject: [PATCH] Build: code style fixes after all those reverts

---
 src/ajax/load.js          |    1 +
 src/core.js               |    1 +
 src/core/init.js          |    4 +-
 src/css.js                |    3 +-
 src/css/defaultDisplay.js |    7 +-
 src/data.js               |    9 +-
 src/deferred.js           |   30 +-
 src/effects.js            |   11 +-
 src/event/alias.js        |    4 +-
 src/manipulation.js       |    4 +-
 src/wrap.js               |   15 +-
 test/data/badjson.js      |    2 +-
 test/data/testinit.js     |    2 +
 test/unit/ajax.js         |   14 +-
 test/unit/attributes.js   |    6 +-
 test/unit/callbacks.js    |    2 +-
 test/unit/core.js         |   50 +-
 test/unit/css.js          |  165 +++--
 test/unit/data.js         |   52 +-
 test/unit/deferred.js     |  239 ++++---
 test/unit/deprecated.js   |    7 +-
 test/unit/dimensions.js   |   20 +-
 test/unit/effects.js      | 1261 +++++++++++++++++++------------------
 test/unit/event.js        |    9 +-
 test/unit/manipulation.js |   11 +-
 test/unit/offset.js       |   22 +-
 test/unit/ready.js        |   49 +-
 test/unit/selector.js     |   28 +-
 test/unit/serialize.js    |   12 +-
 test/unit/support.js      |    2 +-
 30 files changed, 1037 insertions(+), 1005 deletions(-)

diff --git a/src/ajax/load.js b/src/ajax/load.js
index 4ba370e21..7863d7cc2 100644
--- a/src/ajax/load.js
+++ b/src/ajax/load.js
@@ -5,6 +5,7 @@ define( [
 	"../traversing",
 	"../manipulation",
 	"../selector",
+
 	// Optional event/alias dependency
 	"../event/alias"
 ], function( jQuery ) {
diff --git a/src/core.js b/src/core.js
index 5f4e4d9dc..60291a5f0 100644
--- a/src/core.js
+++ b/src/core.js
@@ -290,6 +290,7 @@ jQuery.extend( {
 	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
 	globalEval: function( data ) {
 		if ( data && jQuery.trim( data ) ) {
+
 			// We use execScript on Internet Explorer
 			// We use an anonymous function so that context is window
 			// rather than jQuery in Firefox
diff --git a/src/core/init.js b/src/core/init.js
index 425c1954a..6225d15e4 100644
--- a/src/core/init.js
+++ b/src/core/init.js
@@ -79,7 +79,7 @@ var rootjQuery,
 
 						// Inject the element directly into the jQuery object
 						this.length = 1;
-						this[0] = elem;
+						this[ 0 ] = elem;
 					}
 
 					this.context = document;
@@ -99,7 +99,7 @@ var rootjQuery,
 
 		// HANDLE: $(DOMElement)
 		} else if ( selector.nodeType ) {
-			this.context = this[0] = selector;
+			this.context = this[ 0 ] = selector;
 			this.length = 1;
 			return this;
 
diff --git a/src/css.js b/src/css.js
index 802ae8a31..504192307 100644
--- a/src/css.js
+++ b/src/css.js
@@ -82,6 +82,7 @@ function showHide( elements, show ) {
 		values[ index ] = jQuery._data( elem, "olddisplay" );
 		display = elem.style.display;
 		if ( show ) {
+
 			// Reset the inline display of this element to learn if it is
 			// being hidden by cascaded rules or not
 			if ( !values[ index ] && display === "none" ) {
@@ -92,7 +93,7 @@ function showHide( elements, show ) {
 			// in a stylesheet to whatever the default browser style is
 			// for such an element
 			if ( elem.style.display === "" && isHidden( elem ) ) {
-				values[ index ] = jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
+				values[ index ] = jQuery._data( elem, "olddisplay", defaultDisplay( elem.nodeName ) );
 			}
 		} else {
 			hidden = isHidden( elem );
diff --git a/src/css/defaultDisplay.js b/src/css/defaultDisplay.js
index b1fa7dae5..2ec5d8a7a 100644
--- a/src/css/defaultDisplay.js
+++ b/src/css/defaultDisplay.js
@@ -1,4 +1,4 @@
-define([
+define( [
 	"../core",
 	"../var/document",
 	"../manipulation" // appendTo
@@ -18,6 +18,7 @@ var iframe,
  * @param {String} name nodeName of the element
  * @param {Object} doc Document object
  */
+
 // Called only from within defaultDisplay
 function actualDisplay( name, doc ) {
 	var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
@@ -46,7 +47,7 @@ function defaultDisplay( nodeName ) {
 		if ( display === "none" || !display ) {
 
 			// Use the already-created iframe if possible
-			iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ))
+			iframe = ( iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ) )
 				.appendTo( doc.documentElement );
 
 			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
@@ -68,4 +69,4 @@ function defaultDisplay( nodeName ) {
 }
 
 return defaultDisplay;
-});
+} );
diff --git a/src/data.js b/src/data.js
index d05def4bf..2c4b95748 100644
--- a/src/data.js
+++ b/src/data.js
@@ -47,7 +47,7 @@ function isEmptyDataObject( obj ) {
 	for ( name in obj ) {
 
 		// if the public data object is empty, the private is still empty
-		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+		if ( name === "data" && jQuery.isEmptyObject( obj[ name ] ) ) {
 			continue;
 		}
 		if ( name !== "toJSON" ) {
@@ -80,7 +80,7 @@ function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
 
 	// Avoid doing any more work than we need to when trying to get data on an
 	// object that has no data at all
-	if ( (!id || !cache[id] || (!pvt && !cache[id].data)) &&
+	if ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&
 		data === undefined && typeof name === "string" ) {
 		return;
 	}
@@ -187,10 +187,11 @@ function internalRemoveData( elem, name, pvt ) {
 					if ( name in thisCache ) {
 						name = [ name ];
 					} else {
-						name = name.split(" ");
+						name = name.split( " " );
 					}
 				}
 			} else {
+
 				// If "name" is an array of keys...
 				// When data is initially created, via ("key", "val") signature,
 				// keys will be converted to camelCase.
@@ -202,7 +203,7 @@ function internalRemoveData( elem, name, pvt ) {
 
 			i = name.length;
 			while ( i-- ) {
-				delete thisCache[ name[i] ];
+				delete thisCache[ name[ i ] ];
 			}
 
 			// If there is no data left in the cache, we want to continue
diff --git a/src/deferred.js b/src/deferred.js
index 51a40c7cb..7f43e5f05 100644
--- a/src/deferred.js
+++ b/src/deferred.js
@@ -4,14 +4,15 @@ define( [
 	"./callbacks"
 ], function( jQuery, slice ) {
 
-jQuery.extend({
+jQuery.extend( {
 
 	Deferred: function( func ) {
 		var tuples = [
+
 				// action, add listener, listener list, final state
-				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
-				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
-				[ "notify", "progress", jQuery.Callbacks("memory") ]
+				[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
+				[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
+				[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
 			],
 			state = "pending",
 			promise = {
@@ -24,11 +25,12 @@ jQuery.extend({
 				},
 				then: function( /* fnDone, fnFail, fnProgress */ ) {
 					var fns = arguments;
-					return jQuery.Deferred(function( newDefer ) {
+					return jQuery.Deferred( function( newDefer ) {
 						jQuery.each( tuples, function( i, tuple ) {
 							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
+
 							// deferred[ done | fail | progress ] for forwarding actions to newDefer
-							deferred[ tuple[1] ](function() {
+							deferred[ tuple[ 1 ] ]( function() {
 								var returned = fn && fn.apply( this, arguments );
 								if ( returned && jQuery.isFunction( returned.promise ) ) {
 									returned.promise()
@@ -46,6 +48,7 @@ jQuery.extend({
 						fns = null;
 					} ).promise();
 				},
+
 				// Get a promise for this deferred
 				// If obj is provided, the promise aspect is added to the object
 				promise: function( obj ) {
@@ -63,11 +66,12 @@ jQuery.extend({
 				stateString = tuple[ 3 ];
 
 			// promise[ done | fail | progress ] = list.add
-			promise[ tuple[1] ] = list.add;
+			promise[ tuple[ 1 ] ] = list.add;
 
 			// Handle state
 			if ( stateString ) {
-				list.add(function() {
+				list.add( function() {
+
 					// state = [ resolved | rejected ]
 					state = stateString;
 
@@ -76,12 +80,12 @@ jQuery.extend({
 			}
 
 			// deferred[ resolve | reject | notify ]
-			deferred[ tuple[0] ] = function() {
-				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
+			deferred[ tuple[ 0 ] ] = function() {
+				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
 				return this;
 			};
-			deferred[ tuple[0] + "With" ] = list.fireWith;
-		});
+			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
+		} );
 
 		// Make the deferred a promise
 		promise.promise( deferred );
@@ -117,7 +121,7 @@ jQuery.extend({
 					if ( values === progressValues ) {
 						deferred.notifyWith( contexts, values );
 
-					} else if ( !(--remaining) ) {
+					} else if ( !( --remaining ) ) {
 						deferred.resolveWith( contexts, values );
 					}
 				};
diff --git a/src/effects.js b/src/effects.js
index 27c9cf24c..f005fe204 100644
--- a/src/effects.js
+++ b/src/effects.js
@@ -103,6 +103,7 @@ function defaultPrefilter( elem, props, opts ) {
 
 	// height/width overflow pass
 	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
+
 		// Make sure that nothing sneaks out
 		// Record all 3 overflow attributes because IE does not
 		// change the overflow attribute when overflowX and
@@ -171,17 +172,17 @@ function defaultPrefilter( elem, props, opts ) {
 		if ( hidden ) {
 			jQuery( elem ).show();
 		} else {
-			anim.done(function() {
+			anim.done( function() {
 				jQuery( elem ).hide();
-			});
+			} );
 		}
-		anim.done(function() {
+		anim.done( function() {
 			var prop;
 			jQuery._removeData( elem, "fxshow" );
 			for ( prop in orig ) {
 				jQuery.style( elem, prop, orig[ prop ] );
 			}
-		});
+		} );
 		for ( prop in orig ) {
 			tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
 
@@ -195,7 +196,7 @@ function defaultPrefilter( elem, props, opts ) {
 		}
 
 	// If this is a noop like .hide().hide(), restore an overwritten display value
-	} else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
+	} else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : display ) === "inline" ) {
 		style.display = display;
 	}
 }
diff --git a/src/event/alias.js b/src/event/alias.js
index e94dc8c3a..1f06b8aaa 100644
--- a/src/event/alias.js
+++ b/src/event/alias.js
@@ -3,9 +3,9 @@ define( [
 	"../event"
 ], function( jQuery ) {
 
-jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
+jQuery.each( ( "blur focus focusin focusout load resize scroll unload click dblclick " +
 	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
-	"change select submit keydown keypress keyup error contextmenu").split(" "),
+	"change select submit keydown keypress keyup error contextmenu" ).split( " " ),
 	function( i, name ) {
 
 	// Handle event binding
diff --git a/src/manipulation.js b/src/manipulation.js
index 55efebbc3..da2e055f4 100644
--- a/src/manipulation.js
+++ b/src/manipulation.js
@@ -49,8 +49,8 @@ function manipulationTarget( elem, content ) {
 	return jQuery.nodeName( elem, "table" ) &&
 		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
 
-		elem.getElementsByTagName("tbody")[0] ||
-			elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
+		elem.getElementsByTagName( "tbody" )[ 0 ] ||
+			elem.appendChild( elem.ownerDocument.createElement( "tbody" ) ) :
 		elem;
 }
 
diff --git a/src/wrap.js b/src/wrap.js
index 7740defa1..e50431116 100644
--- a/src/wrap.js
+++ b/src/wrap.js
@@ -8,17 +8,18 @@ define( [
 jQuery.fn.extend( {
 	wrapAll: function( html ) {
 		if ( jQuery.isFunction( html ) ) {
-			return this.each(function(i) {
-				jQuery(this).wrapAll( html.call(this, i) );
-			});
+			return this.each( function( i ) {
+				jQuery( this ).wrapAll( html.call( this, i ) );
+			} );
 		}
 
-		if ( this[0] ) {
+		if ( this[ 0 ] ) {
+
 			// The elements to wrap the target around
-			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
+			var wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
 
-			if ( this[0].parentNode ) {
-				wrap.insertBefore( this[0] );
+			if ( this[ 0 ].parentNode ) {
+				wrap.insertBefore( this[ 0 ] );
 			}
 
 			wrap.map( function() {
diff --git a/test/data/badjson.js b/test/data/badjson.js
index ad2de7a39..d359e824f 100644
--- a/test/data/badjson.js
+++ b/test/data/badjson.js
@@ -1 +1 @@
-{bad: toTheBone}
+{bad: toTheBone;}
diff --git a/test/data/testinit.js b/test/data/testinit.js
index ca8f433d7..4c8d7d972 100644
--- a/test/data/testinit.js
+++ b/test/data/testinit.js
@@ -269,6 +269,7 @@ this.iframeCallback = undefined;
 // Tests are always loaded async
 QUnit.config.autostart = false;
 this.loadTests = function() {
+
 	// Leverage QUnit URL parsing to detect testSwarm environment and "basic" testing mode
 	var loadSwarm = ( QUnit.urlParams[ "swarmURL" ] + "" ).indexOf( "http" ) === 0,
 		basicTests = ( QUnit.urlParams[ "module" ] + "" ) === "basic";
@@ -277,6 +278,7 @@ this.loadTests = function() {
 	require( [ "data/testrunner.js" ], function() {
 		var i = 0,
 			tests = [
+
 				// A special module with basic tests, meant for
 				// not fully supported environments like Android 2.3,
 				// jsdom or PhantomJS. We run it everywhere, though,
diff --git a/test/unit/ajax.js b/test/unit/ajax.js
index e7f38024f..11cb902d2 100644
--- a/test/unit/ajax.js
+++ b/test/unit/ajax.js
@@ -113,7 +113,7 @@ QUnit.module( "ajax", {
 				assert.ok( true, "success" );
 			},
 			fail: function() {
-				if (jQuery.support.cors === false) {
+				if ( jQuery.support.cors === false ) {
 					assert.ok( true, "fail" );
 				}
 			},
@@ -1418,13 +1418,15 @@ QUnit.module( "ajax", {
 	} );
 
 	test( "#11743 - jQuery.ajax() - script, throws exception", 1, function() {
-		throws(function() {
-			jQuery.ajax({
+		throws( function() {
+			jQuery.ajax( {
 				url: "data/badjson.js",
 				dataType: "script",
 				"throws": true,
+
 				// TODO find a way to test this asynchronously, too
 				async: false,
+
 				// Global events get confused by the exception
 				global: false,
 				success: function() {
@@ -1433,9 +1435,9 @@ QUnit.module( "ajax", {
 				error: function() {
 					ok( false, "Error." );
 				}
-			});
+			} );
 		}, "exception bubbled" );
-	});
+	} );
 
 	jQuery.each( [ "method", "type" ], function( _, globalOption ) {
 		function request( assert, option ) {
@@ -1654,7 +1656,7 @@ QUnit.module( "ajax", {
 			url: url( "data/ajax/content-type.php" ),
 			data: {
 				"content-type": "test/jsontest",
-				"response": JSON.stringify({test: "test"})
+				"response": JSON.stringify( { test: "test" } )
 			},
 			success: function( result ) {
 				assert.strictEqual(
diff --git a/test/unit/attributes.js b/test/unit/attributes.js
index 6a8f3acfc..9f8502d5d 100644
--- a/test/unit/attributes.js
+++ b/test/unit/attributes.js
@@ -735,9 +735,9 @@ QUnit.test( "prop('tabindex')", function( assert ) {
 
 QUnit.test( "image.prop( 'tabIndex' )", function( assert ) {
 	assert.expect( 1 );
-	var image = jQuery("<img src='data/1x1.jpg' />")
-		.appendTo("#qunit-fixture");
-	assert.equal( image.prop("tabIndex" ), -1, "tabIndex on image" );
+	var image = jQuery( "<img src='data/1x1.jpg' />" )
+		.appendTo( "#qunit-fixture" );
+	assert.equal( image.prop( "tabIndex" ), -1, "tabIndex on image" );
 } );
 
 QUnit.test( "prop('tabindex', value)", function( assert ) {
diff --git a/test/unit/callbacks.js b/test/unit/callbacks.js
index eec58a80d..f2e07f927 100644
--- a/test/unit/callbacks.js
+++ b/test/unit/callbacks.js
@@ -331,7 +331,7 @@ QUnit.test( "jQuery.Callbacks.has", function( assert ) {
 	assert.strictEqual( cb.has(), true, "Check if unique list has callback function(s) attached" );
 	cb.lock();
 	strictEqual( cb.has(), false, "locked() list is empty and returns false" );
-});
+} );
 
 QUnit.test( "jQuery.Callbacks() - adding a string doesn't cause a stack overflow", function( assert ) {
 
diff --git a/test/unit/core.js b/test/unit/core.js
index 10143408f..84548a0df 100644
--- a/test/unit/core.js
+++ b/test/unit/core.js
@@ -42,7 +42,7 @@ QUnit.test( "jQuery()", function( assert ) {
 	}
 	if ( jQuery.fn.offset ) {
 		expected++;
-		attrObj["offset"] = { "top": 1, "left": 1 };
+		attrObj[ "offset" ] = { "top": 1, "left": 1 };
 	}
 	if ( jQuery.fn.css ) {
 		expected += 2;
@@ -57,12 +57,12 @@ QUnit.test( "jQuery()", function( assert ) {
 
 	// Basic constructor's behavior
 	equal( jQuery().length, 0, "jQuery() === jQuery([])" );
-	equal( jQuery(undefined).length, 0, "jQuery(undefined) === jQuery([])" );
-	equal( jQuery(null).length, 0, "jQuery(null) === jQuery([])" );
-	equal( jQuery("").length, 0, "jQuery('') === jQuery([])" );
-	equal( jQuery("#").length, 0, "jQuery('#') === jQuery([])" );
+	equal( jQuery( undefined ).length, 0, "jQuery(undefined) === jQuery([])" );
+	equal( jQuery( null ).length, 0, "jQuery(null) === jQuery([])" );
+	equal( jQuery( "" ).length, 0, "jQuery('') === jQuery([])" );
+	equal( jQuery( "#" ).length, 0, "jQuery('#') === jQuery([])" );
 
-	equal( jQuery(obj).selector, "div", "jQuery(jQueryObj) == jQueryObj" );
+	equal( jQuery( obj ).selector, "div", "jQuery(jQueryObj) == jQueryObj" );
 
 	// can actually yield more than one, when iframes are included, the window is an array as well
 	assert.equal( jQuery( window ).length, 1, "Correct number of elements generated for jQuery(window)" );
@@ -94,7 +94,7 @@ QUnit.test( "jQuery()", function( assert ) {
 	assert.equal( div.length, 4, "Correct number of elements generated for div hr code b" );
 	assert.equal( div.parent().length, 0, "Make sure that the generated HTML has no parent." );
 
-	assert.equal( jQuery( [ 1,2,3 ] ).get( 1 ), 2, "Test passing an array to the factory" );
+	assert.equal( jQuery( [ 1, 2, 3 ] ).get( 1 ), 2, "Test passing an array to the factory" );
 
 	assert.equal( jQuery( document.body ).get( 0 ), jQuery( "body" ).get( 0 ), "Test passing an html node to the factory" );
 
@@ -104,7 +104,7 @@ QUnit.test( "jQuery()", function( assert ) {
 	elem = jQuery( "\n\n<em>world</em>" )[ 0 ];
 	assert.equal( elem.nodeName.toLowerCase(), "em", "leading newlines" );
 
-	elem = jQuery("<div/>", attrObj );
+	elem = jQuery( "<div/>", attrObj );
 
 	if ( jQuery.fn.width ) {
 		assert.equal( elem[ 0 ].style.width, "10px", "jQuery() quick setter width" );
@@ -115,7 +115,7 @@ QUnit.test( "jQuery()", function( assert ) {
 	}
 
 	if ( jQuery.fn.offset ) {
-		equal( elem[0].style.top, "1px", "jQuery() quick setter offset");
+		equal( elem[ 0 ].style.top, "1px", "jQuery() quick setter offset" );
 	}
 
 	if ( jQuery.fn.css ) {
@@ -172,11 +172,11 @@ test( "selector state", function() {
 	equal( test.selector, "", "Body Selector" );
 	equal( test.context, document.body, "Body Context" );
 
-	test = jQuery("#qunit-fixture");
+	test = jQuery( "#qunit-fixture" );
 	equal( test.selector, "#qunit-fixture", "#qunit-fixture Selector" );
 	equal( test.context, document, "#qunit-fixture Context" );
 
-	test = jQuery("#notfoundnono");
+	test = jQuery( "#notfoundnono" );
 	equal( test.selector, "#notfoundnono", "#notfoundnono Selector" );
 	equal( test.context, document, "#notfoundnono Context" );
 
@@ -193,14 +193,14 @@ test( "selector state", function() {
 	equal( test.selector, "#qunit-fixture", "#qunit-fixture Selector" );
 	equal( test.context, document.body, "#qunit-fixture Context" );
 
-	test = jQuery( document.body ).find("#qunit-fixture");
+	test = jQuery( document.body ).find( "#qunit-fixture" );
 	equal( test.selector, "#qunit-fixture", "#qunit-fixture find Selector" );
 	equal( test.context, document.body, "#qunit-fixture find Context" );
-});
+} );
 
 QUnit.test( "globalEval", function( assert ) {
 	expect( 2 );
-	Globals.register("globalEvalTest");
+	Globals.register( "globalEvalTest" );
 
 	jQuery.globalEval( "var globalEvalTest = 2;" );
 	assert.equal( window.globalEvalTest, 2, "Test variable declarations are global" );
@@ -314,8 +314,9 @@ QUnit.test( "type", function( assert ) {
 } );
 
 QUnit.test( "type for `Symbol`", function( assert ) {
+
 	// Prevent reference errors
-	if( typeof Symbol !== "function" ) {
+	if ( typeof Symbol !== "function" ) {
 		assert.expect( 0 );
 		return;
 	}
@@ -324,7 +325,7 @@ QUnit.test( "type for `Symbol`", function( assert ) {
 
 	assert.equal( jQuery.type( Symbol() ), "symbol", "Symbol" );
 	assert.equal( jQuery.type( Object( Symbol() ) ), "symbol", "Symbol" );
-});
+} );
 
 QUnit.asyncTest( "isPlainObject", function( assert ) {
 	assert.expect( 16 );
@@ -412,7 +413,6 @@ QUnit[ typeof Symbol === "function" ? "test" : "skip" ]( "isPlainObject(Symbol)"
 	assert.equal( jQuery.isPlainObject( Object( Symbol() ) ), false, "Symbol inside an object" );
 } );
 
-
 QUnit.test( "isFunction", function( assert ) {
 	assert.expect( 19 );
 
@@ -963,7 +963,7 @@ QUnit.test( "jQuery.map", function( assert ) {
 	assert.ok( !result, "empty NodeList treated like array" );
 
 	result = jQuery.map( Array( 4 ), function( v, k ) {
-		return k % 2 ? k : [ k,k,k ];
+		return k % 2 ? k : [ k, k, k ];
 	} );
 	assert.equal( result.join( "" ), "00012223", "Array results flattened (#2616)" );
 } );
@@ -1115,7 +1115,7 @@ QUnit.test( "jQuery.grep(Array-like)", function( assert ) {
 		[],
 		"Satisfying elements absent, Array-like object used, and grep explicitly uninverted"
 	);
-});
+} );
 
 QUnit.test( "jQuery.extend(Object, Object)", function( assert ) {
 	assert.expect( 28 );
@@ -1240,19 +1240,19 @@ QUnit.test( "jQuery.extend(Object, Object {created with \"defineProperties\"})",
 
 	assert.expect( 2 );
 
-	var definedObj = Object.defineProperties({}, {
+	var definedObj = Object.defineProperties( {}, {
         "enumerableProp": {
-          get: function () {
+          get: function() {
             return true;
           },
           enumerable: true
         },
         "nonenumerableProp": {
-          get: function () {
+          get: function() {
             return true;
           }
         }
-      }),
+      } ),
       accessorObj = {};
 
 	jQuery.extend( accessorObj, definedObj );
@@ -1287,7 +1287,7 @@ QUnit.test( "jQuery.each(Object,Function)", function( assert ) {
 	assert.deepEqual( seen, [ 1, 2 ], "Broken array iteration" );
 
 	seen = [];
-	jQuery.each( { "a": 1, "b": 2,"c": 3 }, function( k, v ) {
+	jQuery.each( { "a": 1, "b": 2, "c": 3 }, function( k, v ) {
 		seen.push( v );
 		return false;
 	} );
@@ -1407,7 +1407,7 @@ QUnit.test( "jQuery.makeArray", function( assert ) {
 
 	assert.equal( ( function() { return jQuery.makeArray( arguments ); } )( 1, 2 ).join( "" ), "12", "Pass makeArray an arguments array" );
 
-	assert.equal( jQuery.makeArray( [ 1,2,3 ] ).join( "" ), "123", "Pass makeArray a real array" );
+	assert.equal( jQuery.makeArray( [ 1, 2, 3 ] ).join( "" ), "123", "Pass makeArray a real array" );
 
 	assert.equal( jQuery.makeArray().length, 0, "Pass nothing to makeArray and expect an empty array" );
 
diff --git a/test/unit/css.js b/test/unit/css.js
index 9e6f7b138..df4b800f0 100644
--- a/test/unit/css.js
+++ b/test/unit/css.js
@@ -119,7 +119,6 @@ QUnit.test( "css(String|Hash)", function( assert ) {
 		"Make sure that a string z-index is returned from css('z-index') (#14432)." );
 } );
 
-
 QUnit.test( "css() explicit and relative values", function( assert ) {
 	assert.expect( 29 );
 
@@ -516,14 +515,14 @@ QUnit.test( "show(); hide()", function( assert ) {
 
 	hiddendiv = jQuery( "div.hidden" );
 	hiddendiv.hide();
-	equal( hiddendiv.css("display"), "none", "Non-detached div hidden" );
+	equal( hiddendiv.css( "display" ), "none", "Non-detached div hidden" );
 	hiddendiv.show();
-	equal( hiddendiv.css("display"), "block", "Pre-hidden div shown" );
+	equal( hiddendiv.css( "display" ), "block", "Pre-hidden div shown" );
 
-	div = jQuery("<div>").hide();
-	equal( div.css("display"), "none", "Detached div hidden" );
-	div.appendTo("#qunit-fixture").show();
-	equal( div.css("display"), "block", "Pre-hidden div shown" );
+	div = jQuery( "<div>" ).hide();
+	equal( div.css( "display" ), "none", "Detached div hidden" );
+	div.appendTo( "#qunit-fixture" ).show();
+	equal( div.css( "display" ), "block", "Pre-hidden div shown" );
 
 } );
 
@@ -532,7 +531,7 @@ QUnit.test( "show();", function( assert ) {
 	assert.expect( 18 );
 
 	var hiddendiv, div, pass, test;
-	hiddendiv = jQuery("div.hidden");
+	hiddendiv = jQuery( "div.hidden" );
 
 	assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "none", "hiddendiv is display: none" );
 
@@ -554,7 +553,7 @@ QUnit.test( "show();", function( assert ) {
 	assert.ok( pass, "Show" );
 
 	// #show-tests * is set display: none in CSS
-	jQuery("#qunit-fixture").append("<div id='show-tests'><div><p><a href='#'></a></p><code></code><pre></pre><span></span></div><table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table><ul><li></li></ul></div>");
+	jQuery( "#qunit-fixture" ).append( "<div id='show-tests'><div><p><a href='#'></a></p><code></code><pre></pre><span></span></div><table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table><ul><li></li></ul></div>" );
 
 	test = {
 		"div": "block",
@@ -583,109 +582,109 @@ QUnit.test( "show();", function( assert ) {
 	jQuery( "<div>test</div> text <span>test</span>" ).hide().remove();
 } );
 
-test("show() resolves correct default display #8099", function() {
-	expect(7);
-	var tt8099 = jQuery("<tt/>").appendTo("body"),
-			dfn8099 = jQuery("<dfn/>", { "html": "foo"}).appendTo("body");
+test( "show() resolves correct default display #8099", function() {
+	expect( 7 );
+	var tt8099 = jQuery( "<tt/>" ).appendTo( "body" ),
+			dfn8099 = jQuery( "<dfn/>", { "html": "foo" } ).appendTo( "body" );
 
-	equal( tt8099.css("display"), "none", "default display override for all tt" );
-	equal( tt8099.show().css("display"), "inline", "Correctly resolves display:inline" );
+	equal( tt8099.css( "display" ), "none", "default display override for all tt" );
+	equal( tt8099.show().css( "display" ), "inline", "Correctly resolves display:inline" );
 
-	equal( jQuery("#foo").hide().show().css("display"), "block", "Correctly resolves display:block after hide/show" );
+	equal( jQuery( "#foo" ).hide().show().css( "display" ), "block", "Correctly resolves display:block after hide/show" );
 
-	equal( tt8099.hide().css("display"), "none", "default display override for all tt" );
-	equal( tt8099.show().css("display"), "inline", "Correctly resolves display:inline" );
+	equal( tt8099.hide().css( "display" ), "none", "default display override for all tt" );
+	equal( tt8099.show().css( "display" ), "inline", "Correctly resolves display:inline" );
 
-	equal( dfn8099.css("display"), "none", "default display override for all dfn" );
-	equal( dfn8099.show().css("display"), "inline", "Correctly resolves display:inline" );
+	equal( dfn8099.css( "display" ), "none", "default display override for all dfn" );
+	equal( dfn8099.show().css( "display" ), "inline", "Correctly resolves display:inline" );
 
 	tt8099.remove();
 	dfn8099.remove();
-});
+} );
 
 QUnit.test( "show() resolves correct default display for detached nodes", function( assert ) {
 	assert.expect( 13 );
 
 	var div, span, tr, trDisplay;
 
-	div = jQuery("<div class='hidden'>");
-	div.show().appendTo("#qunit-fixture");
-	equal( div.css("display"), "block", "Make sure a detached, pre-hidden( through stylesheets ) div is visible." );
+	div = jQuery( "<div class='hidden'>" );
+	div.show().appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "block", "Make sure a detached, pre-hidden( through stylesheets ) div is visible." );
 
-	div = jQuery("<div style='display: none'>");
-	div.show().appendTo("#qunit-fixture");
-	equal( div.css("display"), "block", "Make sure a detached, pre-hidden( through inline style ) div is visible." );
+	div = jQuery( "<div style='display: none'>" );
+	div.show().appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "block", "Make sure a detached, pre-hidden( through inline style ) div is visible." );
 
-	span = jQuery("<span class='hidden'/>");
-	span.show().appendTo("#qunit-fixture");
-	equal( span.css("display"), "inline", "Make sure a detached, pre-hidden( through stylesheets ) span has default display." );
+	span = jQuery( "<span class='hidden'/>" );
+	span.show().appendTo( "#qunit-fixture" );
+	equal( span.css( "display" ), "inline", "Make sure a detached, pre-hidden( through stylesheets ) span has default display." );
 
-	span = jQuery("<span style='display: inline'/>");
-	span.show().appendTo("#qunit-fixture");
-	equal( span.css("display"), "inline", "Make sure a detached, pre-hidden( through inline style ) span has default display." );
+	span = jQuery( "<span style='display: inline'/>" );
+	span.show().appendTo( "#qunit-fixture" );
+	equal( span.css( "display" ), "inline", "Make sure a detached, pre-hidden( through inline style ) span has default display." );
 
-	div = jQuery("<div><div class='hidden'></div></div>").children("div");
-	div.show().appendTo("#qunit-fixture");
-	equal( div.css("display"), "block", "Make sure a detached, pre-hidden( through stylesheets ) div inside another visible div is visible." );
+	div = jQuery( "<div><div class='hidden'></div></div>" ).children( "div" );
+	div.show().appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "block", "Make sure a detached, pre-hidden( through stylesheets ) div inside another visible div is visible." );
 
-	div = jQuery("<div><div style='display: none'></div></div>").children("div");
-	div.show().appendTo("#qunit-fixture");
-	equal( div.css("display"), "block", "Make sure a detached, pre-hidden( through inline style ) div inside another visible div is visible." );
+	div = jQuery( "<div><div style='display: none'></div></div>" ).children( "div" );
+	div.show().appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "block", "Make sure a detached, pre-hidden( through inline style ) div inside another visible div is visible." );
 
 	div = jQuery( "div.hidden" );
 	div.detach().show();
 
-	equal( div.css("display"), "block", "Make sure a detached( through detach() ), pre-hidden div is visible." );
+	equal( div.css( "display" ), "block", "Make sure a detached( through detach() ), pre-hidden div is visible." );
 	div.remove();
 
-	span = jQuery("<span>");
-	span.appendTo("#qunit-fixture").detach().show().appendTo("#qunit-fixture" );
-	equal( span.css("display"), "inline", "Make sure a detached( through detach() ), pre-hidden span has default display." );
+	span = jQuery( "<span>" );
+	span.appendTo( "#qunit-fixture" ).detach().show().appendTo( "#qunit-fixture" );
+	equal( span.css( "display" ), "inline", "Make sure a detached( through detach() ), pre-hidden span has default display." );
 	span.remove();
 
-	div = jQuery("<div>");
-	div.show().appendTo("#qunit-fixture");
+	div = jQuery( "<div>" );
+	div.show().appendTo( "#qunit-fixture" );
 	ok( !!div.get( 0 ).style.display, "Make sure not hidden div has a inline style." );
 	div.remove();
 
-	div = jQuery( document.createElement("div") );
-	div.show().appendTo("#qunit-fixture");
-	equal( div.css("display"), "block", "Make sure a pre-created element has default display." );
+	div = jQuery( document.createElement( "div" ) );
+	div.show().appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "block", "Make sure a pre-created element has default display." );
 	div.remove();
 
-	div = jQuery("<div style='display: inline'/>");
-	div.show().appendTo("#qunit-fixture");
-	equal( div.css("display"), "inline", "Make sure that element has same display when it was created." );
+	div = jQuery( "<div style='display: inline'/>" );
+	div.show().appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "inline", "Make sure that element has same display when it was created." );
 	div.remove();
 
-	tr = jQuery("<tr/>");
-	jQuery("#table").append( tr );
+	tr = jQuery( "<tr/>" );
+	jQuery( "#table" ).append( tr );
 	trDisplay = tr.css( "display" );
 	tr.detach().hide().show();
 
 	equal( tr[ 0 ].style.display, trDisplay, "For detached tr elements, display should always be like for attached trs" );
 	tr.remove();
 
-	span = jQuery("<span/>").hide().show();
+	span = jQuery( "<span/>" ).hide().show();
 	equal( span[ 0 ].style.display, "inline", "For detached span elements, display should always be inline" );
 	span.remove();
 } );
 
-test("show() resolves correct default display #10227", 4, function() {
+test( "show() resolves correct default display #10227", 4, function() {
 	var htmlDisplay,
 		html = jQuery( document.documentElement ),
 		body = jQuery( "body" );
 
 	body.append( "<p class='ddisplay'>a<style>body{display:none}</style></p>" );
 
-	equal( body.css("display"), "none", "Initial display for body element: none" );
+	equal( body.css( "display" ), "none", "Initial display for body element: none" );
 
 	body.show();
-	equal( body.css("display"), "block", "Correct display for body element: block" );
+	equal( body.css( "display" ), "block", "Correct display for body element: block" );
 
 	body.append( "<p class='ddisplay'>a<style>html{display:none}</style></p>" );
 
-	equal( html.css("display"), "none", "Initial display for html element: none" );
+	equal( html.css( "display" ), "none", "Initial display for html element: none" );
 
 	html.show();
 	htmlDisplay = html.css( "display" );
@@ -696,22 +695,22 @@ test("show() resolves correct default display #10227", 4, function() {
 	jQuery._removeData( body[ 0 ] );
 	jQuery._removeData( html[ 0 ] );
 	jQuery( ".ddisplay" ).remove();
-});
+} );
 
-test("show() resolves correct default display when iframe display:none #12904", function() {
-	expect(2);
+test( "show() resolves correct default display when iframe display:none #12904", function() {
+	expect( 2 );
 
 	var ddisplay = jQuery(
 		"<p id='ddisplay'>a<style>p{display:none}iframe{display:none !important}</style></p>"
-	).appendTo("body");
+	).appendTo( "body" );
 
-	equal( ddisplay.css("display"), "none", "Initial display: none" );
+	equal( ddisplay.css( "display" ), "none", "Initial display: none" );
 
 	ddisplay.show();
-	equal( ddisplay.css("display"), "block", "Correct display: block" );
+	equal( ddisplay.css( "display" ), "block", "Correct display: block" );
 
 	ddisplay.remove();
-});
+} );
 
 QUnit.test( "toggle()", function( assert ) {
 	assert.expect( 9 );
@@ -752,7 +751,7 @@ QUnit.test( "hide hidden elements (bug #7141)", function( assert ) {
 	var div = jQuery( "<div style='display:none'></div>" ).appendTo( "#qunit-fixture" );
 	assert.equal( div.css( "display" ), "none", "Element is hidden by default" );
 	div.hide();
-	ok( !jQuery._data(div, "olddisplay"), "olddisplay is undefined after hiding an already-hidden element" );
+	ok( !jQuery._data( div, "olddisplay" ), "olddisplay is undefined after hiding an already-hidden element" );
 	div.show();
 	assert.equal( div.css( "display" ), "block", "Show a double-hidden element" );
 
@@ -797,18 +796,18 @@ QUnit.test( "computed margins (trac-3333; gh-2237)", function( assert ) {
 	assert.equal( $div.css( "marginRight" ), "0px",
 		"marginRight correctly calculated with a width and display block" );
 
-	$div.css({
+	$div.css( {
 		position: "absolute",
 		top: 0,
 		left: 0,
 		width: "100px"
-	});
-	$child.css({
+	} );
+	$child.css( {
 		width: "50px",
 		margin: "auto"
-	});
+	} );
 	assert.equal( $child.css( "marginLeft" ), "25px", "auto margins are computed to pixels" );
-});
+} );
 
 QUnit.test( "box model properties incorrectly returning % instead of px, see #10639 and #12088", function( assert ) {
 	assert.expect( 2 );
@@ -956,8 +955,8 @@ testIframeWithCallback(
 	}
 );
 
-QUnit.test("certain css values of 'normal' should be convertable to a number, see #8627", function( assert ) {
-	expect ( 3 );
+QUnit.test( "certain css values of 'normal' should be convertable to a number, see #8627", function( assert ) {
+	expect( 3 );
 
 	var el = jQuery( "<div style='letter-spacing:normal;font-weight:normal;'>test</div>" ).appendTo( "#qunit-fixture" );
 
@@ -1073,7 +1072,7 @@ QUnit.test( ":visible/:hidden selectors", function( assert ) {
 
 	assert.t( "Is Visible", "#qunit-fixture div:visible:lt(2)", [ "foo", "nothiddendiv" ] );
 	assert.t( "Is Not Hidden", "#qunit-fixture:hidden", [] );
-	assert.t( "Is Hidden", "#form input:hidden", [ "hidden1","hidden2" ] );
+	assert.t( "Is Hidden", "#form input:hidden", [ "hidden1", "hidden2" ] );
 
 	$a = jQuery( "<a href='#'><h1>Header</h1></a>" ).appendTo( "#qunit-fixture" );
 	assert.ok( $a.is( ":visible" ), "Anchor tag with flow content is visible (gh-2227)" );
@@ -1109,7 +1108,7 @@ QUnit.test(
 				name: "backgroundAttachment",
 				value: [ "fixed" ],
 				expected: [ "scroll" ]
-			},{
+			}, {
 				name: "backgroundColor",
 				value: [ "rgb(255, 0, 0)", "rgb(255,0,0)", "#ff0000" ],
 				expected: [ "transparent" ]
@@ -1199,27 +1198,27 @@ QUnit.test( "show() after hide() should always set display to initial value (#14
 } );
 
 asyncTest( "Make sure initialized display value for disconnected nodes is correct (#13310)", 4, function() {
-	var display = jQuery("#display").css("display"),
-		div = jQuery("<div/>");
+	var display = jQuery( "#display" ).css( "display" ),
+		div = jQuery( "<div/>" );
 
-	equal( div.css( "display", "inline" ).hide().show().appendTo("body").css( "display" ), "inline", "Initialized display value has returned" );
+	equal( div.css( "display", "inline" ).hide().show().appendTo( "body" ).css( "display" ), "inline", "Initialized display value has returned" );
 	div.remove();
 
 	div.css( "display", "none" ).hide();
 	equal( jQuery._data( div[ 0 ], "olddisplay" ), undefined, "olddisplay is undefined after hiding a detached and hidden element" );
 	div.remove();
 
-	div.css( "display", "inline-block" ).hide().appendTo("body").fadeIn(function() {
+	div.css( "display", "inline-block" ).hide().appendTo( "body" ).fadeIn( function() {
 		equal( div.css( "display" ), "inline-block", "Initialized display value has returned" );
 		div.remove();
 
 		start();
-	});
+	} );
 
-	equal( jQuery._data( jQuery("#display").css( "display", "inline" ).hide()[ 0 ], "olddisplay" ), display,
+	equal( jQuery._data( jQuery( "#display" ).css( "display", "inline" ).hide()[ 0 ], "olddisplay" ), display,
 	"display: * !Important value should used as initialized display" );
-	jQuery._removeData( jQuery("#display")[ 0 ] );
-});
+	jQuery._removeData( jQuery( "#display" )[ 0 ] );
+} );
 
 QUnit.test( "show() after hide() should always set display to initial value (#14750)", 1, function( assert ) {
 	var div = jQuery( "<div />" ),
diff --git a/test/unit/data.js b/test/unit/data.js
index c402e20bb..54611a1cc 100644
--- a/test/unit/data.js
+++ b/test/unit/data.js
@@ -378,25 +378,25 @@ QUnit.test( "data-* attributes", function( assert ) {
 	var prop, i, l, metadata, elem,
 		obj, obj2, check, num, num2,
 		parseJSON = jQuery.parseJSON,
-		div = jQuery("<div>"),
-		child = jQuery("<div data-myobj='old data' data-ignored=\"DOM\" data-other='test'></div>"),
-		dummy = jQuery("<div data-myobj='old data' data-ignored=\"DOM\" data-other='test'></div>");
+		div = jQuery( "<div>" ),
+		child = jQuery( "<div data-myobj='old data' data-ignored=\"DOM\" data-other='test'></div>" ),
+		dummy = jQuery( "<div data-myobj='old data' data-ignored=\"DOM\" data-other='test'></div>" );
 
-	equal( div.data("attr"), undefined, "Check for non-existing data-attr attribute" );
+	equal( div.data( "attr" ), undefined, "Check for non-existing data-attr attribute" );
 
-	div.attr("data-attr", "exists");
-	equal( div.data("attr"), "exists", "Check for existing data-attr attribute" );
+	div.attr( "data-attr", "exists" );
+	equal( div.data( "attr" ), "exists", "Check for existing data-attr attribute" );
 
-	div.attr("data-attr", "exists2");
-	equal( div.data("attr"), "exists", "Check that updates to data- don't update .data()" );
+	div.attr( "data-attr", "exists2" );
+	equal( div.data( "attr" ), "exists", "Check that updates to data- don't update .data()" );
 
-	div.data("attr", "internal").attr("data-attr", "external");
-	equal( div.data("attr"), "internal", "Check for .data('attr') precedence (internal > external data-* attribute)" );
+	div.data( "attr", "internal" ).attr( "data-attr", "external" );
+	equal( div.data( "attr" ), "internal", "Check for .data('attr') precedence (internal > external data-* attribute)" );
 
 	div.remove();
 
-	child.appendTo("#qunit-fixture");
-	equal( child.data("myobj"), "old data", "Value accessed from data-* attribute");
+	child.appendTo( "#qunit-fixture" );
+	equal( child.data( "myobj" ), "old data", "Value accessed from data-* attribute" );
 
 	child.data( "myobj", "replaced" );
 	assert.equal(
@@ -567,7 +567,7 @@ QUnit.test( "data-* attributes", function( assert ) {
 		jQuery( elem ).data( "number" ), true, "Check number property"
 	);
 			assert.deepEqual(
-		jQuery( elem ).data( "stuff" ), [ 2,8 ], "Check stuff property"
+		jQuery( elem ).data( "stuff" ), [ 2, 8 ], "Check stuff property"
 	);
 			break;
 		default:
@@ -830,10 +830,9 @@ QUnit.test(
 	}
 );
 
+test( "jQuery.data supports interoperable hyphenated/camelCase get/set of properties with arbitrary non-null|NaN|undefined values", function() {
 
-test("jQuery.data supports interoperable hyphenated/camelCase get/set of properties with arbitrary non-null|NaN|undefined values", function() {
-
-	var div = jQuery("<div/>", { id: "hyphened" }).appendTo("#qunit-fixture"),
+	var div = jQuery( "<div/>", { id: "hyphened" } ).appendTo( "#qunit-fixture" ),
 		datas = {
 			"non-empty": "a string",
 			"empty-string": "",
@@ -843,6 +842,7 @@ test("jQuery.data supports interoperable hyphenated/camelCase get/set of propert
 			"an-object": {},
 			"bool-true": true,
 			"bool-false": false,
+
 			// JSHint enforces double quotes,
 			// but JSON strings need double quotes to parse
 			// so we need escaped double quotes here
@@ -859,40 +859,42 @@ test("jQuery.data supports interoperable hyphenated/camelCase get/set of propert
 
 		deepEqual( div.data( key ), val, "get: " + key );
 		deepEqual( div.data( jQuery.camelCase( key ) ), val, "get: " + jQuery.camelCase( key ) );
-	});
-});
+	} );
+} );
 
 test( ".removeData supports removal of hyphenated properties via array (#12786)", function() {
 	expect( 4 );
 
 	var div, plain, compare;
 
-	div = jQuery("<div>").appendTo("#qunit-fixture");
-	plain = jQuery({});
+	div = jQuery( "<div>" ).appendTo( "#qunit-fixture" );
+	plain = jQuery( {} );
 
 	// When data is batch assigned (via plain object), the properties
 	// are not camel cased as they are with (property, value) calls
 	compare = {
+
 		// From batch assignment .data({ "a-a": 1 })
 		"a-a": 1,
+
 		// From property, value assignment .data( "b-b", 1 )
 		"bB": 1
 	};
 
 	// Mixed assignment
-	div.data({ "a-a": 1 }).data( "b-b", 1 );
-	plain.data({ "a-a": 1 }).data( "b-b", 1 );
+	div.data( { "a-a": 1 } ).data( "b-b", 1 );
+	plain.data( { "a-a": 1 } ).data( "b-b", 1 );
 
 	deepEqual( div.data(), compare, "Data appears as expected. (div)" );
 	deepEqual( plain.data(), compare, "Data appears as expected. (plain)" );
 
-	div.removeData([ "a-a", "b-b" ]);
-	plain.removeData([ "a-a", "b-b" ]);
+	div.removeData( [ "a-a", "b-b" ] );
+	plain.removeData( [ "a-a", "b-b" ] );
 
 	// NOTE: Timo's proposal for "propEqual" (or similar) would be nice here
 	deepEqual( div.data(), {}, "Data is empty. (div)" );
 	deepEqual( plain.data(), {}, "Data is empty. (plain)" );
-});
+} );
 
 // Test originally by Moschel
 QUnit.test( "Triggering the removeData should not throw exceptions. (#10080)", function( assert ) {
diff --git a/test/unit/deferred.js b/test/unit/deferred.js
index 40f936219..93b4c25c7 100644
--- a/test/unit/deferred.js
+++ b/test/unit/deferred.js
@@ -1,6 +1,6 @@
 module( "deferred", {
 	teardown: moduleTeardown
-});
+} );
 
 jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
 
@@ -16,32 +16,32 @@ jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
 
 		strictEqual( defer.pipe, defer.then, "pipe is an alias of then" );
 
-		createDeferred().resolve().done(function() {
+		createDeferred().resolve().done( function() {
 			ok( true, "Success on resolve" );
 			strictEqual( this.state(), "resolved", "Deferred is resolved (state)" );
-		}).fail(function() {
+		} ).fail( function() {
 			ok( false, "Error on resolve" );
-		}).always(function() {
+		} ).always( function() {
 			ok( true, "Always callback on resolve" );
-		});
+		} );
 
-		createDeferred().reject().done(function() {
+		createDeferred().reject().done( function() {
 			ok( false, "Success on reject" );
-		}).fail(function() {
+		} ).fail( function() {
 			ok( true, "Error on reject" );
 			strictEqual( this.state(), "rejected", "Deferred is rejected (state)" );
-		}).always(function() {
+		} ).always( function() {
 			ok( true, "Always callback on reject" );
-		});
+		} );
 
-		createDeferred(function( defer ) {
+		createDeferred( function( defer ) {
 			ok( this === defer, "Defer passed as this & first argument" );
-			this.resolve("done");
-		}).done(function( value ) {
+			this.resolve( "done" );
+		} ).done( function( value ) {
 			strictEqual( value, "done", "Passed function executed" );
-		});
+		} );
 
-		createDeferred(function( defer ) {
+		createDeferred( function( defer ) {
 			var promise = defer.promise(),
 				func = function() {},
 				funcPromise = defer.promise( func );
@@ -54,17 +54,17 @@ jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
 				if ( promise[ key ] !== func[ key ] ) {
 					strictEqual( func[ key ], promise[ key ], key + " is the same" );
 				}
-			});
-		});
+			} );
+		} );
 
 		jQuery.expandedEach = jQuery.each;
-		jQuery.expandedEach( "resolve reject".split(" "), function( _, change ) {
-			createDeferred(function( defer ) {
+		jQuery.expandedEach( "resolve reject".split( " " ), function( _, change ) {
+			createDeferred( function( defer ) {
 				strictEqual( defer.state(), "pending", "pending after creation" );
 				var checked = 0;
-				defer.progress(function( value ) {
+				defer.progress( function( value ) {
 					strictEqual( value, checked, "Progress: right value (" + value + ") received" );
-				});
+				} );
 				for ( checked = 0; checked < 3; checked++ ) {
 					defer.notify( checked );
 				}
@@ -72,11 +72,10 @@ jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
 				defer[ change ]();
 				notStrictEqual( defer.state(), "pending", "not pending after " + change );
 				defer.notify();
-			});
-		});
-	});
-});
-
+			} );
+		} );
+	} );
+} );
 
 test( "jQuery.Deferred - chainability", function() {
 
@@ -85,13 +84,13 @@ test( "jQuery.Deferred - chainability", function() {
 	expect( 10 );
 
 	jQuery.expandedEach = jQuery.each;
-	jQuery.expandedEach( "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split(" "), function( _, method ) {
+	jQuery.expandedEach( "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split( " " ), function( _, method ) {
 		var object = {
 			m: defer[ method ]
 		};
 		strictEqual( object.m(), object, method + " is chainable" );
-	});
-});
+	} );
+} );
 
 test( "jQuery.Deferred.then - filtering (done)", function() {
 
@@ -99,18 +98,18 @@ test( "jQuery.Deferred.then - filtering (done)", function() {
 
 	var value1, value2, value3,
 		defer = jQuery.Deferred(),
-		piped = defer.then(function( a, b ) {
+		piped = defer.then( function( a, b ) {
 			return a * b;
-		});
+		} );
 
-	piped.done(function( result ) {
+	piped.done( function( result ) {
 		value3 = result;
-	});
+	} );
 
-	defer.done(function( a, b ) {
+	defer.done( function( a, b ) {
 		value1 = a;
 		value2 = b;
-	});
+	} );
 
 	defer.resolve( 2, 3 );
 
@@ -118,14 +117,14 @@ test( "jQuery.Deferred.then - filtering (done)", function() {
 	strictEqual( value2, 3, "second resolve value ok" );
 	strictEqual( value3, 6, "result of filter ok" );
 
-	jQuery.Deferred().reject().then(function() {
+	jQuery.Deferred().reject().then( function() {
 		ok( false, "then should not be called on reject" );
-	});
+	} );
 
-	jQuery.Deferred().resolve().then( jQuery.noop ).done(function( value ) {
+	jQuery.Deferred().resolve().then( jQuery.noop ).done( function( value ) {
 		strictEqual( value, undefined, "then done callback can return undefined/null" );
-	});
-});
+	} );
+} );
 
 test( "jQuery.Deferred.then - filtering (fail)", function() {
 
@@ -135,16 +134,16 @@ test( "jQuery.Deferred.then - filtering (fail)", function() {
 		defer = jQuery.Deferred(),
 		piped = defer.then( null, function( a, b ) {
 			return a * b;
-		});
+		} );
 
-	piped.fail(function( result ) {
+	piped.fail( function( result ) {
 		value3 = result;
-	});
+	} );
 
-	defer.fail(function( a, b ) {
+	defer.fail( function( a, b ) {
 		value1 = a;
 		value2 = b;
-	});
+	} );
 
 	defer.reject( 2, 3 );
 
@@ -154,12 +153,12 @@ test( "jQuery.Deferred.then - filtering (fail)", function() {
 
 	jQuery.Deferred().resolve().then( null, function() {
 		ok( false, "then should not be called on resolve" );
-	});
+	} );
 
-	jQuery.Deferred().reject().then( null, jQuery.noop ).fail(function( value ) {
+	jQuery.Deferred().reject().then( null, jQuery.noop ).fail( function( value ) {
 		strictEqual( value, undefined, "then fail callback can return undefined/null" );
-	});
-});
+	} );
+} );
 
 test( "jQuery.Deferred.then - filtering (progress)", function() {
 
@@ -169,23 +168,23 @@ test( "jQuery.Deferred.then - filtering (progress)", function() {
 		defer = jQuery.Deferred(),
 		piped = defer.then( null, null, function( a, b ) {
 			return a * b;
-		});
+		} );
 
-	piped.progress(function( result ) {
+	piped.progress( function( result ) {
 		value3 = result;
-	});
+	} );
 
-	defer.progress(function( a, b ) {
+	defer.progress( function( a, b ) {
 		value1 = a;
 		value2 = b;
-	});
+	} );
 
 	defer.notify( 2, 3 );
 
 	strictEqual( value1, 2, "first progress value ok" );
 	strictEqual( value2, 3, "second progress value ok" );
 	strictEqual( value3, 6, "result of filter ok" );
-});
+} );
 
 test( "jQuery.Deferred.then - deferred (done)", function() {
 
@@ -193,27 +192,27 @@ test( "jQuery.Deferred.then - deferred (done)", function() {
 
 	var value1, value2, value3,
 		defer = jQuery.Deferred(),
-		piped = defer.then(function( a, b ) {
-			return jQuery.Deferred(function( defer ) {
+		piped = defer.then( function( a, b ) {
+			return jQuery.Deferred( function( defer ) {
 				defer.reject( a * b );
-			});
-		});
+			} );
+		} );
 
-	piped.fail(function( result ) {
+	piped.fail( function( result ) {
 		value3 = result;
-	});
+	} );
 
-	defer.done(function( a, b ) {
+	defer.done( function( a, b ) {
 		value1 = a;
 		value2 = b;
-	});
+	} );
 
 	defer.resolve( 2, 3 );
 
 	strictEqual( value1, 2, "first resolve value ok" );
 	strictEqual( value2, 3, "second resolve value ok" );
 	strictEqual( value3, 6, "result of filter ok" );
-});
+} );
 
 test( "jQuery.Deferred.then - deferred (fail)", function() {
 
@@ -222,26 +221,26 @@ test( "jQuery.Deferred.then - deferred (fail)", function() {
 	var value1, value2, value3,
 		defer = jQuery.Deferred(),
 		piped = defer.then( null, function( a, b ) {
-			return jQuery.Deferred(function( defer ) {
+			return jQuery.Deferred( function( defer ) {
 				defer.resolve( a * b );
-			});
-		});
+			} );
+		} );
 
-	piped.done(function( result ) {
+	piped.done( function( result ) {
 		value3 = result;
-	});
+	} );
 
-	defer.fail(function( a, b ) {
+	defer.fail( function( a, b ) {
 		value1 = a;
 		value2 = b;
-	});
+	} );
 
 	defer.reject( 2, 3 );
 
 	strictEqual( value1, 2, "first reject value ok" );
 	strictEqual( value2, 3, "second reject value ok" );
 	strictEqual( value3, 6, "result of filter ok" );
-});
+} );
 
 test( "jQuery.Deferred.then - deferred (progress)", function() {
 
@@ -250,26 +249,26 @@ test( "jQuery.Deferred.then - deferred (progress)", function() {
 	var value1, value2, value3,
 		defer = jQuery.Deferred(),
 		piped = defer.then( null, null, function( a, b ) {
-			return jQuery.Deferred(function( defer ) {
+			return jQuery.Deferred( function( defer ) {
 				defer.resolve( a * b );
-			});
-		});
+			} );
+		} );
 
-	piped.done(function( result ) {
+	piped.done( function( result ) {
 		value3 = result;
-	});
+	} );
 
-	defer.progress(function( a, b ) {
+	defer.progress( function( a, b ) {
 		value1 = a;
 		value2 = b;
-	});
+	} );
 
 	defer.notify( 2, 3 );
 
 	strictEqual( value1, 2, "first progress value ok" );
 	strictEqual( value2, 3, "second progress value ok" );
 	strictEqual( value3, 6, "result of filter ok" );
-});
+} );
 
 test( "jQuery.Deferred.then - context", function() {
 
@@ -278,48 +277,48 @@ test( "jQuery.Deferred.then - context", function() {
 	var defer, piped, defer2, piped2,
 		context = {};
 
-	jQuery.Deferred().resolveWith( context, [ 2 ] ).then(function( value ) {
+	jQuery.Deferred().resolveWith( context, [ 2 ] ).then( function( value ) {
 		return value * 3;
-	}).done(function( value ) {
+	} ).done( function( value ) {
 		strictEqual( this, context, "custom context correctly propagated" );
 		strictEqual( value, 6, "proper value received" );
-	});
+	} );
 
-	jQuery.Deferred().resolve().then(function() {
-		return jQuery.Deferred().resolveWith(context);
-	}).done(function() {
+	jQuery.Deferred().resolve().then( function() {
+		return jQuery.Deferred().resolveWith( context );
+	} ).done( function() {
 		strictEqual( this, context, "custom context of returned deferred correctly propagated" );
-	});
+	} );
 
 	defer = jQuery.Deferred();
-	piped = defer.then(function( value ) {
+	piped = defer.then( function( value ) {
 		return value * 3;
-	});
+	} );
 
 	defer.resolve( 2 );
 
-	piped.done(function( value ) {
+	piped.done( function( value ) {
 		strictEqual( this, piped, "default context gets updated to latest promise in the chain" );
 		strictEqual( value, 6, "proper value received" );
-	});
+	} );
 
 	defer2 = jQuery.Deferred();
 	piped2 = defer2.then();
 
 	defer2.resolve( 2 );
 
-	piped2.done(function( value ) {
+	piped2.done( function( value ) {
 		strictEqual( this, piped2, "default context gets updated to latest promise in the chain (without passing function)" );
 		strictEqual( value, 2, "proper value received (without passing function)" );
-	});
-});
+	} );
+} );
 
 test( "jQuery.when", function() {
 
 	expect( 37 );
 
 	// Some other objects
-	jQuery.each({
+	jQuery.each( {
 		"an empty string": "",
 		"a non-empty string": "some string",
 		"zero": 0,
@@ -334,21 +333,21 @@ test( "jQuery.when", function() {
 	}, function( message, value ) {
 		ok(
 			jQuery.isFunction(
-				jQuery.when( value ).done(function( resolveValue ) {
+				jQuery.when( value ).done( function( resolveValue ) {
 					strictEqual( this, window, "Context is the global object with " + message );
 					strictEqual( resolveValue, value, "Test the promise was resolved with " + message );
-				}).promise
+				} ).promise
 			),
 			"Test " + message + " triggers the creation of a new Promise"
 		);
-	});
+	} );
 
 	ok(
 		jQuery.isFunction(
-			jQuery.when().done(function( resolveValue ) {
+			jQuery.when().done( function( resolveValue ) {
 				strictEqual( this, window, "Test the promise was resolved with window as its context" );
 				strictEqual( resolveValue, undefined, "Test the promise was resolved with no parameter" );
-			}).promise
+			} ).promise
 		),
 		"Test calling when with no parameter triggers the creation of a new Promise"
 	);
@@ -356,23 +355,23 @@ test( "jQuery.when", function() {
 	var cache,
 		context = {};
 
-	jQuery.when( jQuery.Deferred().resolveWith( context ) ).done(function() {
+	jQuery.when( jQuery.Deferred().resolveWith( context ) ).done( function() {
 		strictEqual( this, context, "when( promise ) propagates context" );
-	});
+	} );
 
-	jQuery.each([ 1, 2, 3 ], function( k, i ) {
+	jQuery.each( [ 1, 2, 3 ], function( k, i ) {
 
-		jQuery.when( cache || jQuery.Deferred(function() {
+		jQuery.when( cache || jQuery.Deferred( function() {
 				this.resolve( i );
-			})
-		).done(function( value ) {
+			} )
+		).done( function( value ) {
 
 			strictEqual( value, 1, "Function executed" + ( i > 1 ? " only once" : "" ) );
 			cache = value;
-		});
+		} );
 
-	});
-});
+	} );
+} );
 
 test( "jQuery.when - joined", function() {
 
@@ -412,7 +411,7 @@ test( "jQuery.when - joined", function() {
 				context1 = defer1 && jQuery.isFunction( defer1.promise ) ? defer1.promise() : undefined,
 				context2 = defer2 && jQuery.isFunction( defer2.promise ) ? defer2.promise() : undefined;
 
-			jQuery.when( defer1, defer2 ).done(function( a, b ) {
+			jQuery.when( defer1, defer2 ).done( function( a, b ) {
 				if ( shouldResolve ) {
 					deepEqual( [ a, b ], expected, code + " => resolve" );
 					strictEqual( this[ 0 ], context1, code + " => first context OK" );
@@ -420,22 +419,22 @@ test( "jQuery.when - joined", function() {
 				} else {
 					ok( false,  code + " => resolve" );
 				}
-			}).fail(function( a, b ) {
+			} ).fail( function( a, b ) {
 				if ( shouldError ) {
 					deepEqual( [ a, b ], expected, code + " => reject" );
 				} else {
 					ok( false, code + " => reject" );
 				}
-			}).progress(function( a, b ) {
+			} ).progress( function( a, b ) {
 				deepEqual( [ a, b ], expectedNotify, code + " => progress" );
 				strictEqual( this[ 0 ], expectedNotify[ 0 ] ? context1 : undefined, code + " => first context OK" );
 				strictEqual( this[ 1 ], expectedNotify[ 1 ] ? context2 : undefined, code + " => second context OK" );
-			});
-		});
-	});
+			} );
+		} );
+	} );
 	deferreds.futureSuccess.resolve( 1 );
 	deferreds.futureError.reject( 0 );
-});
+} );
 
 test( "jQuery.when - resolved", function() {
 
@@ -445,16 +444,16 @@ test( "jQuery.when - resolved", function() {
 		b = jQuery.Deferred().notify( 2 ).resolve( 5 ),
 		c = jQuery.Deferred().notify( 3 ).resolve( 6 );
 
-	jQuery.when( a, b, c ).progress(function( a, b, c ) {
+	jQuery.when( a, b, c ).progress( function( a, b, c ) {
 		strictEqual( a, 1, "first notify value ok" );
 		strictEqual( b, 2, "second notify value ok" );
 		strictEqual( c, 3, "third notify value ok" );
-	}).done(function( a, b, c ) {
+	} ).done( function( a, b, c ) {
 		strictEqual( a, 4, "first resolve value ok" );
 		strictEqual( b, 5, "second resolve value ok" );
 		strictEqual( c, 6, "third resolve value ok" );
-	}).fail(function() {
+	} ).fail( function() {
 		ok( false, "Error on resolve" );
-	});
+	} );
 
-});
+} );
diff --git a/test/unit/deprecated.js b/test/unit/deprecated.js
index 797290f3b..f474dc6c3 100644
--- a/test/unit/deprecated.js
+++ b/test/unit/deprecated.js
@@ -1,6 +1,5 @@
 QUnit.module( "deprecated", { teardown: moduleTeardown } );
 
-
 QUnit.test( "bind/unbind", function( assert ) {
 	assert.expect( 4 );
 
@@ -14,7 +13,7 @@ QUnit.test( "bind/unbind", function( assert ) {
 			assert.equal( e.type, "click", "correct event type" );
 			assert.equal( e.data.bindData, 19, "correct trigger data" );
 			assert.equal( trig, 42, "correct bind data" );
-			assert.equal( e.target.nodeName.toLowerCase(), "b" , "correct element" );
+			assert.equal( e.target.nodeName.toLowerCase(), "b", "correct element" );
 		} )
 		.trigger( "click", [ 42 ] )
 		.unbind( "click" )
@@ -32,11 +31,11 @@ QUnit.test( "delegate/undelegate", function( assert ) {
 	markup
 		.delegate( "b", "click", function( e ) {
 			assert.equal( e.type, "click", "correct event type" );
-			assert.equal( e.target.nodeName.toLowerCase(), "b" , "correct element" );
+			assert.equal( e.target.nodeName.toLowerCase(), "b", "correct element" );
 		} )
 		.find( "b" )
 			.trigger( "click" )
 			.end()
 		.undelegate( "b", "click" )
 		.remove();
-} );
\ No newline at end of file
+} );
diff --git a/test/unit/dimensions.js b/test/unit/dimensions.js
index 17f133dce..33fc71d18 100644
--- a/test/unit/dimensions.js
+++ b/test/unit/dimensions.js
@@ -57,7 +57,7 @@ function testWidth( val, assert ) {
 
 	assert.equal( jQuery( window ).width(), document.documentElement.clientWidth, "Window width is equal to width reported by window/document." );
 
-	QUnit.expectJqData( this, $div[0], "olddisplay" );
+	QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
 }
 
 QUnit.test( "width()", function( assert ) {
@@ -110,7 +110,7 @@ function testHeight( val, assert ) {
 
 	assert.equal( jQuery( window ).height(), document.documentElement.clientHeight, "Window width is equal to width reported by window/document." );
 
-	QUnit.expectJqData( this, $div[0], "olddisplay" );
+	QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
 }
 
 QUnit.test( "height()", function( assert ) {
@@ -167,7 +167,7 @@ QUnit.test( "innerWidth()", function( assert ) {
 	div.remove();
 
 	QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
 
 QUnit.test( "innerHeight()", function( assert ) {
 	assert.expect( 6 );
@@ -202,7 +202,7 @@ QUnit.test( "innerHeight()", function( assert ) {
 
 	div.remove();
 	QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
 
 QUnit.test( "outerWidth()", function( assert ) {
 	assert.expect( 11 );
@@ -241,7 +241,7 @@ QUnit.test( "outerWidth()", function( assert ) {
 
 	div.remove();
 	QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
 
 QUnit.test( "child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height()  see #9441 #9300", function( assert ) {
 	assert.expect( 16 );
@@ -262,7 +262,7 @@ QUnit.test( "child of a hidden elem (or unconnected node) has accurate inner/out
 	equal( $divChild.height(), $divNormal.height(), "child of a hidden element height() is wrong see #9441" );
 	equal( $divChild.innerHeight(), $divNormal.innerHeight(), "child of a hidden element innerHeight() is wrong see #9441" );
 	equal( $divChild.outerHeight(), $divNormal.outerHeight(), "child of a hidden element outerHeight() is wrong see #9441" );
-	equal( $divChild.outerHeight(true), $divNormal.outerHeight( true ), "child of a hidden element outerHeight( true ) is wrong see #9300" );
+	equal( $divChild.outerHeight( true ), $divNormal.outerHeight( true ), "child of a hidden element outerHeight( true ) is wrong see #9300" );
 
 	// tests that child div of an unconnected div works the same as a normal div
 	assert.equal( $divUnconnected.width(), $divNormal.width(), "unconnected element width() is wrong see #9441" );
@@ -273,7 +273,7 @@ QUnit.test( "child of a hidden elem (or unconnected node) has accurate inner/out
 	equal( $divUnconnected.height(), $divNormal.height(), "unconnected element height() is wrong see #9441" );
 	equal( $divUnconnected.innerHeight(), $divNormal.innerHeight(), "unconnected element innerHeight() is wrong see #9441" );
 	equal( $divUnconnected.outerHeight(), $divNormal.outerHeight(), "unconnected element outerHeight() is wrong see #9441" );
-	equal( $divUnconnected.outerHeight(true), $divNormal.outerHeight( true ), "unconnected element outerHeight( true ) is wrong see #9300" );
+	equal( $divUnconnected.outerHeight( true ), $divNormal.outerHeight( true ), "unconnected element outerHeight( true ) is wrong see #9300" );
 
 	// teardown html
 	$divHiddenParent.remove();
@@ -335,7 +335,7 @@ QUnit.test( "box-sizing:border-box child of a hidden elem (or unconnected node)
 	equal( $divChild.height(), $divNormal.height(), "child of a hidden element height() is wrong see #10413" );
 	equal( $divChild.innerHeight(), $divNormal.innerHeight(), "child of a hidden element innerHeight() is wrong see #10413" );
 	equal( $divChild.outerHeight(), $divNormal.outerHeight(), "child of a hidden element outerHeight() is wrong see #10413" );
-	equal( $divChild.outerHeight(true), $divNormal.outerHeight( true ), "child of a hidden element outerHeight( true ) is wrong see #10413" );
+	equal( $divChild.outerHeight( true ), $divNormal.outerHeight( true ), "child of a hidden element outerHeight( true ) is wrong see #10413" );
 
 	// tests that child div of an unconnected div works the same as a normal div
 	assert.equal( $divUnconnected.width(), $divNormal.width(), "unconnected element width() is wrong see #10413" );
@@ -346,7 +346,7 @@ QUnit.test( "box-sizing:border-box child of a hidden elem (or unconnected node)
 	equal( $divUnconnected.height(), $divNormal.height(), "unconnected element height() is wrong see #10413" );
 	equal( $divUnconnected.innerHeight(), $divNormal.innerHeight(), "unconnected element innerHeight() is wrong see #10413" );
 	equal( $divUnconnected.outerHeight(), $divNormal.outerHeight(), "unconnected element outerHeight() is wrong see #10413" );
-	equal( $divUnconnected.outerHeight(true), $divNormal.outerHeight( true ), "unconnected element outerHeight( true ) is wrong see #10413" );
+	equal( $divUnconnected.outerHeight( true ), $divNormal.outerHeight( true ), "unconnected element outerHeight( true ) is wrong see #10413" );
 
 	// teardown html
 	$divHiddenParent.remove();
@@ -389,7 +389,7 @@ QUnit.test( "outerHeight()", function( assert ) {
 
 	div.remove();
 	QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
 
 QUnit.test( "passing undefined is a setter #5571", function( assert ) {
 	assert.expect( 4 );
diff --git a/test/unit/effects.js b/test/unit/effects.js
index 03191236a..78dbe9dca 100644
--- a/test/unit/effects.js
+++ b/test/unit/effects.js
@@ -1,11 +1,11 @@
-(function() {
+( function() {
 
 // Can't test what ain't there
 if ( !jQuery.fx ) {
 	return;
 }
 
-module("effects", {
+module( "effects", {
 	setup: function() {
 		this.clock = sinon.useFakeTimers( 505877050 );
 		this._oldInterval = jQuery.fx.interval;
@@ -17,53 +17,53 @@ module("effects", {
 		jQuery.fx.interval = this._oldInterval;
 		return moduleTeardown.apply( this, arguments );
 	}
-});
+} );
 
 QUnit.test( "sanity check", function( assert ) {
 	assert.expect( 1 );
 	assert.equal( jQuery( "#dl:visible, #qunit-fixture:visible, #foo:visible" ).length, 3, "QUnit state is correct for testing effects" );
 } );
 
-test("show() basic", 2, function() {
+test( "show() basic", 2, function() {
 	var div,
-		hiddendiv = jQuery("div.hidden");
+		hiddendiv = jQuery( "div.hidden" );
 
 	hiddendiv.hide().show();
 
-	equal( hiddendiv.css("display"), "block", "Make sure a pre-hidden div is visible." );
+	equal( hiddendiv.css( "display" ), "block", "Make sure a pre-hidden div is visible." );
 
-	div = jQuery("<div>").hide().appendTo("#qunit-fixture").show();
+	div = jQuery( "<div>" ).hide().appendTo( "#qunit-fixture" ).show();
 
-	equal( div.css("display"), "block", "Make sure pre-hidden divs show" );
+	equal( div.css( "display" ), "block", "Make sure pre-hidden divs show" );
 
 	// Clean up the detached node
 	div.remove();
 
 	QUnit.expectJqData( this, hiddendiv, "olddisplay" );
-});
+} );
 
-test("show()", 27, function () {
+test( "show()", 27, function() {
 	var div, speeds, test,
 		displaysActual, displaysExpected,
-		hiddendiv = jQuery("div.hidden");
+		hiddendiv = jQuery( "div.hidden" );
 
-	equal(jQuery.css( hiddendiv[0], "display"), "none", "hiddendiv is display: none");
+	equal( jQuery.css( hiddendiv[ 0 ], "display" ), "none", "hiddendiv is display: none" );
 
-	hiddendiv.css("display", "block");
-	equal(jQuery.css( hiddendiv[0], "display"), "block", "hiddendiv is display: block");
+	hiddendiv.css( "display", "block" );
+	equal( jQuery.css( hiddendiv[ 0 ], "display" ), "block", "hiddendiv is display: block" );
 
 	hiddendiv.show();
-	equal(jQuery.css( hiddendiv[0], "display"), "block", "hiddendiv is display: block");
+	equal( jQuery.css( hiddendiv[ 0 ], "display" ), "block", "hiddendiv is display: block" );
 
-	hiddendiv.css("display","");
+	hiddendiv.css( "display", "" );
 
 	displaysActual = [];
 	displaysExpected = [];
 
-	div = jQuery("#fx-queue div").slice(0, 4);
-	div.show().each(function() {
-		notEqual(this.style.display, "none", "don't change any <div> with display block");
-	});
+	div = jQuery( "#fx-queue div" ).slice( 0, 4 );
+	div.show().each( function() {
+		notEqual( this.style.display, "none", "don't change any <div> with display block" );
+	} );
 
 	speeds = {
 		"null speed": null,
@@ -71,147 +71,146 @@ test("show()", 27, function () {
 		"false speed": false
 	};
 
-	jQuery.each(speeds, function(name, speed) {
+	jQuery.each( speeds, function( name, speed ) {
 		var pass = true;
-		div.hide().show(speed).each(function() {
+		div.hide().show( speed ).each( function() {
 			if ( this.style.display === "none" ) {
 				pass = false;
 			}
-		});
-		ok( pass, "Show with " + name);
-	});
+		} );
+		ok( pass, "Show with " + name );
+	} );
 
-	jQuery.each(speeds, function(name, speed) {
+	jQuery.each( speeds, function( name, speed ) {
 		var pass = true;
-		div.hide().show(speed, function() {
+		div.hide().show( speed, function() {
 			pass = false;
-		});
+		} );
 		ok( pass, "Show with " + name + " does not call animate callback" );
-	});
+	} );
 
 	// Tolerate data from show()/hide()
 	QUnit.expectJqData( this, div, "olddisplay" );
 
 	// #show-tests * is set display: none in CSS
-	jQuery("#qunit-fixture").append("<div id='show-tests'><div><p><a href='#'></a></p><code></code><pre></pre><span></span></div><table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table><ul><li></li></ul></div>");
+	jQuery( "#qunit-fixture" ).append( "<div id='show-tests'><div><p><a href='#'></a></p><code></code><pre></pre><span></span></div><table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table><ul><li></li></ul></div>" );
 
 	test = {
-		"div"      : "block",
-		"p"        : "block",
-		"a"        : "inline",
-		"code"     : "inline",
-		"pre"      : "block",
-		"span"     : "inline",
-		"table"    : "table",
-		"thead"    : "table-header-group",
-		"tbody"    : "table-row-group",
-		"tr"       : "table-row",
-		"th"       : "table-cell",
-		"td"       : "table-cell",
-		"ul"       : "block",
-		"li"       : "list-item"
+		"div": "block",
+		"p": "block",
+		"a": "inline",
+		"code": "inline",
+		"pre": "block",
+		"span": "inline",
+		"table": "table",
+		"thead": "table-header-group",
+		"tbody": "table-row-group",
+		"tr": "table-row",
+		"th": "table-cell",
+		"td": "table-cell",
+		"ul": "block",
+		"li": "list-item"
 	};
 
-	jQuery.each(test, function(selector, expected) {
-		var elem = jQuery(selector, "#show-tests").show();
-		equal( elem.css("display"), expected, "Show using correct display type for " + selector );
-	});
+	jQuery.each( test, function( selector, expected ) {
+		var elem = jQuery( selector, "#show-tests" ).show();
+		equal( elem.css( "display" ), expected, "Show using correct display type for " + selector );
+	} );
 
-	jQuery("#show-tests").remove();
+	jQuery( "#show-tests" ).remove();
 
 	// Make sure that showing or hiding a text node doesn't cause an error
-	jQuery("<div>test</div> text <span>test</span>").show().remove();
-	jQuery("<div>test</div> text <span>test</span>").hide().remove();
-});
-
-test("show(Number) - other displays", function() {
-	expect(15);
+	jQuery( "<div>test</div> text <span>test</span>" ).show().remove();
+	jQuery( "<div>test</div> text <span>test</span>" ).hide().remove();
+} );
 
+test( "show(Number) - other displays", function() {
+	expect( 15 );
 
 	// #show-tests * is set display: none in CSS
-	jQuery("#qunit-fixture").append("<div id='show-tests'><div><p><a href='#'></a></p><code></code><pre></pre><span></span></div><table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table><ul><li></li></ul></div>");
+	jQuery( "#qunit-fixture" ).append( "<div id='show-tests'><div><p><a href='#'></a></p><code></code><pre></pre><span></span></div><table><thead><tr><th></th></tr></thead><tbody><tr><td></td></tr></tbody></table><ul><li></li></ul></div>" );
 
 	// Note: inline elements are expected to be inline-block
 	// because we're showing width/height
 	// Can't animate width/height inline
 	// See #14344
 	var test = {
-		"div"      : "block",
-		"p"        : "block",
-		"a"        : "inline-block",
-		"code"     : "inline-block",
-		"pre"      : "block",
-		"span"     : "inline-block",
-		"table"    : "table",
-		"thead"    : "table-header-group",
-		"tbody"    : "table-row-group",
-		"tr"       : "table-row",
-		"th"       : "table-cell",
-		"td"       : "table-cell",
-		"ul"       : "block",
-		"li"       : "list-item"
+		"div": "block",
+		"p": "block",
+		"a": "inline-block",
+		"code": "inline-block",
+		"pre": "block",
+		"span": "inline-block",
+		"table": "table",
+		"thead": "table-header-group",
+		"tbody": "table-row-group",
+		"tr": "table-row",
+		"th": "table-cell",
+		"td": "table-cell",
+		"ul": "block",
+		"li": "list-item"
 	};
 
-	jQuery.each(test, function(selector, expected) {
-		var elem = jQuery(selector, "#show-tests").show(1, function() {
-			equal( elem.css("display"), expected, "Show using correct display type for " + selector );
-		});
-	});
+	jQuery.each( test, function( selector, expected ) {
+		var elem = jQuery( selector, "#show-tests" ).show( 1, function() {
+			equal( elem.css( "display" ), expected, "Show using correct display type for " + selector );
+		} );
+	} );
 	this.clock.tick( 10 );
 
-	jQuery("#show-tests").remove();
-});
+	jQuery( "#show-tests" ).remove();
+} );
 
 // Supports #7397
-test("Persist correct display value", function() {
-	expect(3);
+test( "Persist correct display value", function() {
+	expect( 3 );
 
 	// #show-tests * is set display: none in CSS
-	jQuery("#qunit-fixture").append("<div id='show-tests'><span style='position:absolute;'>foo</span></div>");
+	jQuery( "#qunit-fixture" ).append( "<div id='show-tests'><span style='position:absolute;'>foo</span></div>" );
 
-	var $span = jQuery("#show-tests span"),
-		displayNone = $span.css("display"),
+	var $span = jQuery( "#show-tests span" ),
+		displayNone = $span.css( "display" ),
 		display = "",
 		clock = this.clock;
 
 	$span.show();
 
-	display = $span.css("display");
+	display = $span.css( "display" );
 
 	$span.hide();
 
-	$span.fadeIn(100, function() {
-		equal($span.css("display"), display, "Expecting display: " + display);
-		$span.fadeOut(100, function () {
-			equal($span.css("display"), displayNone, "Expecting display: " + displayNone);
-			$span.fadeIn(100, function() {
-				equal($span.css("display"), display, "Expecting display: " + display);
-			});
-		});
-	});
+	$span.fadeIn( 100, function() {
+		equal( $span.css( "display" ), display, "Expecting display: " + display );
+		$span.fadeOut( 100, function() {
+			equal( $span.css( "display" ), displayNone, "Expecting display: " + displayNone );
+			$span.fadeIn( 100, function() {
+				equal( $span.css( "display" ), display, "Expecting display: " + display );
+			} );
+		} );
+	} );
 
 	clock.tick( 300 );
 
 	QUnit.expectJqData( this, $span, "olddisplay" );
-});
+} );
 
-test("animate(Hash, Object, Function)", function() {
-	expect(1);
-	var hash = {opacity: "show"},
-		hashCopy = jQuery.extend({}, hash);
-	jQuery("#foo").animate(hash, 0, function() {
+test( "animate(Hash, Object, Function)", function() {
+	expect( 1 );
+	var hash = { opacity: "show" },
+		hashCopy = jQuery.extend( {}, hash );
+	jQuery( "#foo" ).animate( hash, 0, function() {
 		equal( hash.opacity, hashCopy.opacity, "Check if animate changed the hash parameter" );
-	});
-});
+	} );
+} );
 
-test("animate relative values", function() {
+test( "animate relative values", function() {
 
 	var value = 40,
 		clock = this.clock,
 		bases = [ "%", "px", "em" ],
 		adjustments = [ "px", "em" ],
-		container = jQuery("<div></div>")
-			.css({ position: "absolute", height: "50em", width: "50em" }),
+		container = jQuery( "<div></div>" )
+			.css( { position: "absolute", height: "50em", width: "50em" } ),
 		animations = bases.length * adjustments.length;
 
 	expect( 2 * animations );
@@ -220,13 +219,13 @@ test("animate relative values", function() {
 		jQuery.each( adjustments, function( _, adjustUnit ) {
 			var base = value + baseUnit,
 				adjust = { height: "+=2" + adjustUnit, width: "-=2" + adjustUnit },
-				elem = jQuery("<div></div>")
-					.appendTo( container.clone().appendTo("#qunit-fixture") )
-					.css({
+				elem = jQuery( "<div></div>" )
+					.appendTo( container.clone().appendTo( "#qunit-fixture" ) )
+					.css( {
 						position: "absolute",
 						height: base,
 						width: value + adjustUnit
-					}),
+					} ),
 				baseScale = elem[ 0 ].offsetHeight / value,
 				adjustScale = elem[ 0 ].offsetWidth / value;
 
@@ -236,89 +235,89 @@ test("animate relative values", function() {
 				equal( this.offsetWidth, value * baseScale - 2 * adjustScale,
 					baseUnit + "-=" + adjustUnit );
 
-			});
+			} );
 
 			clock.tick( 100 );
-		});
-	});
-});
+		} );
+	} );
+} );
 
-test("animate negative height", function() {
-	expect(1);
-	jQuery("#foo").animate({ height: -100 }, 100, function() {
+test( "animate negative height", function() {
+	expect( 1 );
+	jQuery( "#foo" ).animate( { height: -100 }, 100, function() {
 		equal( this.offsetHeight, 0, "Verify height." );
-	});
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate negative margin", function() {
-	expect(1);
-	jQuery("#foo").animate({ "marginTop": -100 }, 100, function() {
-		equal( jQuery(this).css("marginTop"), "-100px", "Verify margin." );
-	});
+test( "animate negative margin", function() {
+	expect( 1 );
+	jQuery( "#foo" ).animate( { "marginTop": -100 }, 100, function() {
+		equal( jQuery( this ).css( "marginTop" ), "-100px", "Verify margin." );
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate negative margin with px", function() {
-	expect(1);
-	jQuery("#foo").animate({ marginTop: "-100px" }, 100, function() {
-		equal( jQuery(this).css("marginTop"), "-100px", "Verify margin." );
-	});
+test( "animate negative margin with px", function() {
+	expect( 1 );
+	jQuery( "#foo" ).animate( { marginTop: "-100px" }, 100, function() {
+		equal( jQuery( this ).css( "marginTop" ), "-100px", "Verify margin." );
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate negative padding", function() {
-	expect(1);
-	jQuery("#foo").animate({ "paddingBottom": -100 }, 100, function() {
-		equal( jQuery(this).css("paddingBottom"), "0px", "Verify paddingBottom." );
-	});
+test( "animate negative padding", function() {
+	expect( 1 );
+	jQuery( "#foo" ).animate( { "paddingBottom": -100 }, 100, function() {
+		equal( jQuery( this ).css( "paddingBottom" ), "0px", "Verify paddingBottom." );
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate block as inline width/height", function() {
-	expect(3);
+test( "animate block as inline width/height", function() {
+	expect( 3 );
 
-	var span = jQuery("<span>").css("display", "inline-block").appendTo("body");
+	var span = jQuery( "<span>" ).css( "display", "inline-block" ).appendTo( "body" );
 
 	span.remove();
 
-	jQuery("#foo").css({ display: "inline", width: "", height: "" }).animate({ width: 42, height: 42 }, 100, function() {
-		equal( jQuery(this).css("display"), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
+	jQuery( "#foo" ).css( { display: "inline", width: "", height: "" } ).animate( { width: 42, height: 42 }, 100, function() {
+		equal( jQuery( this ).css( "display" ), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
 		equal( this.offsetWidth, 42, "width was animated" );
 		equal( this.offsetHeight, 42, "height was animated" );
-	});
+	} );
 
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate native inline width/height", function() {
-	expect(3);
+test( "animate native inline width/height", function() {
+	expect( 3 );
 
-	var span = jQuery("<span>").css("display", "inline-block").appendTo("body");
+	var span = jQuery( "<span>" ).css( "display", "inline-block" ).appendTo( "body" );
 
 	span.remove();
 
-	jQuery("#foo").css({ display: "", width: "", height: "" })
-		.append("<span>text</span>")
-		.children("span")
-			.animate({ width: 42, height: 42 }, 100, function() {
-				equal( jQuery(this).css("display"), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
+	jQuery( "#foo" ).css( { display: "", width: "", height: "" } )
+		.append( "<span>text</span>" )
+		.children( "span" )
+			.animate( { width: 42, height: 42 }, 100, function() {
+				equal( jQuery( this ).css( "display" ), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
 				equal( this.offsetWidth, 42, "width was animated" );
 				equal( this.offsetHeight, 42, "height was animated" );
-			});
+			} );
 
 	this.clock.tick( 100 );
-});
+} );
 
 test( "animate block width/height", function() {
 	expect( 3 );
 
-	jQuery("<div>").appendTo("#qunit-fixture").css({
+	jQuery( "<div>" ).appendTo( "#qunit-fixture" ).css( {
 		display: "block",
 		width: 20,
 		height: 20,
 		paddingLeft: 60
-	}).animate({
+	} ).animate( {
 		width: 42,
 		height: 42
 	}, {
@@ -329,78 +328,78 @@ test( "animate block width/height", function() {
 			}
 		},
 		complete: function() {
-			equal( jQuery( this ).css("display"), "block", "inline-block was not set on block element when animating width/height" );
+			equal( jQuery( this ).css( "display" ), "block", "inline-block was not set on block element when animating width/height" );
 			equal( jQuery( this ).width(), 42, "width was animated" );
 			equal( jQuery( this ).height(), 42, "height was animated" );
 		}
-	});
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
 test( "animate table width/height", function() {
-	expect(1);
+	expect( 1 );
 
-	jQuery( "#table" ).animate({ width: 42, height: 42 }, 100, function() {
+	jQuery( "#table" ).animate( { width: 42, height: 42 }, 100, function() {
 		equal( jQuery( this ).css( "display" ), "table", "display mode is correct" );
-	});
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate table-row width/height", function() {
-	expect(3);
-	var tr = jQuery("#table")
-			.attr({ "cellspacing": 0, "cellpadding": 0, "border": 0 })
-			.html("<tr style='height:42px;'><td style='padding:0;'><div style='width:20px;height:20px;'></div></td></tr>")
-			.find("tr");
+test( "animate table-row width/height", function() {
+	expect( 3 );
+	var tr = jQuery( "#table" )
+			.attr( { "cellspacing": 0, "cellpadding": 0, "border": 0 } )
+			.html( "<tr style='height:42px;'><td style='padding:0;'><div style='width:20px;height:20px;'></div></td></tr>" )
+			.find( "tr" );
 
-	tr.animate({ width: 10, height: 10 }, 100, function() {
+	tr.animate( { width: 10, height: 10 }, 100, function() {
 		equal( jQuery( this ).css( "display" ), "table-row", "display mode is correct" );
 		equal( this.offsetWidth, 20, "width animated to shrink wrap point" );
 		equal( this.offsetHeight, 20, "height animated to shrink wrap point" );
-	});
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate table-cell width/height", function() {
-	expect(3);
+test( "animate table-cell width/height", function() {
+	expect( 3 );
 
 	var td = jQuery( "#table" )
-			.attr({ "cellspacing": 0, "cellpadding": 0, "border": 0 })
+			.attr( { "cellspacing": 0, "cellpadding": 0, "border": 0 } )
 			.html( "<tr><td style='width:42px;height:42px;padding:0;'><div style='width:20px;height:20px;'></div></td></tr>" )
 			.find( "td" );
 
-	td.animate({ width: 10, height: 10 }, 100, function() {
+	td.animate( { width: 10, height: 10 }, 100, function() {
 		equal( jQuery( this ).css( "display" ), "table-cell", "display mode is correct" );
 		equal( this.offsetWidth, 20, "width animated to shrink wrap point" );
 		equal( this.offsetHeight, 20, "height animated to shrink wrap point" );
-	});
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("animate percentage(%) on width/height", function() {
+test( "animate percentage(%) on width/height", function() {
 	expect( 2 );
 
-	var $div = jQuery("<div style='position:absolute;top:-999px;left:-999px;width:60px;height:60px;'><div style='width:50%;height:50%;'></div></div>")
-		.appendTo("#qunit-fixture").children("div");
+	var $div = jQuery( "<div style='position:absolute;top:-999px;left:-999px;width:60px;height:60px;'><div style='width:50%;height:50%;'></div></div>" )
+		.appendTo( "#qunit-fixture" ).children( "div" );
 
-	$div.animate({ width: "25%", height: "25%" }, 13, function() {
-		var $this = jQuery(this);
-		equal( $this.css("width"), "15px", "Width was animated to 15px rather than 25px");
-		equal( $this.css("height"), "15px", "Height was animated to 15px rather than 25px");
-	});
+	$div.animate( { width: "25%", height: "25%" }, 13, function() {
+		var $this = jQuery( this );
+		equal( $this.css( "width" ), "15px", "Width was animated to 15px rather than 25px" );
+		equal( $this.css( "height" ), "15px", "Height was animated to 15px rather than 25px" );
+	} );
 	this.clock.tick( 20 );
-});
+} );
 
-test("animate resets overflow-x and overflow-y when finished", function() {
-	expect(2);
-	jQuery("#foo")
-		.css({ display: "block", width: 20, height: 20, overflowX: "visible", overflowY: "auto" })
-		.animate({ width: 42, height: 42 }, 100, function() {
+test( "animate resets overflow-x and overflow-y when finished", function() {
+	expect( 2 );
+	jQuery( "#foo" )
+		.css( { display: "block", width: 20, height: 20, overflowX: "visible", overflowY: "auto" } )
+		.animate( { width: 42, height: 42 }, 100, function() {
 			equal( this.style.overflowX, "visible", "overflow-x is visible" );
 			equal( this.style.overflowY, "auto", "overflow-y is auto" );
-		});
+		} );
 	this.clock.tick( 100 );
-});
+} );
 
 /* // This test ends up being flaky depending upon the CPU load
 test("animate option (queue === false)", function () {
@@ -427,7 +426,7 @@ test( "animate option { queue: false }", function() {
 	expect( 2 );
 	var foo = jQuery( "#foo" );
 
-	foo.animate({
+	foo.animate( {
 		fontSize: "2em"
 	}, {
 		queue: false,
@@ -435,17 +434,17 @@ test( "animate option { queue: false }", function() {
 		complete: function() {
 			ok( true, "Animation Completed" );
 		}
-	});
+	} );
 	this.clock.tick( 10 );
 
 	equal( foo.queue().length, 0, "Queue is empty" );
-});
+} );
 
 test( "animate option { queue: true }", function() {
 	expect( 2 );
 	var foo = jQuery( "#foo" );
 
-	foo.animate({
+	foo.animate( {
 		fontSize: "2em"
 	}, {
 		queue: true,
@@ -453,18 +452,18 @@ test( "animate option { queue: true }", function() {
 		complete: function() {
 			ok( true, "Animation Completed" );
 		}
-	});
+	} );
 
 	notEqual( foo.queue().length, 0, "Default queue is not empty" );
 
 	//clear out existing timers before next test
 	this.clock.tick( 10 );
-});
+} );
 
 test( "animate option { queue: 'name' }", function() {
 	expect( 5 );
 	var foo = jQuery( "#foo" ),
-		origWidth = parseFloat( foo.css("width") ),
+		origWidth = parseFloat( foo.css( "width" ) ),
 		order = [];
 
 	foo.animate( { width: origWidth + 100 }, {
@@ -474,128 +473,127 @@ test( "animate option { queue: 'name' }", function() {
 
 			// second callback function
 			order.push( 2 );
-			equal( parseFloat( foo.css("width") ), origWidth + 100, "Animation ended" );
-			equal( foo.queue("name").length, 1, "Queue length of 'name' queue" );
+			equal( parseFloat( foo.css( "width" ) ), origWidth + 100, "Animation ended" );
+			equal( foo.queue( "name" ).length, 1, "Queue length of 'name' queue" );
 		}
-	}).queue( "name", function() {
+	} ).queue( "name", function() {
 
 		// last callback function
 		deepEqual( order, [ 1, 2 ], "Callbacks in expected order" );
-	});
-
+	} );
 
 	// this is the first callback function that should be called
 	order.push( 1 );
-	equal( parseFloat( foo.css("width") ), origWidth, "Animation does not start on its own." );
-	equal( foo.queue("name").length, 2, "Queue length of 'name' queue" );
+	equal( parseFloat( foo.css( "width" ) ), origWidth, "Animation does not start on its own." );
+	equal( foo.queue( "name" ).length, 2, "Queue length of 'name' queue" );
 
 	foo.dequeue( "name" );
 	this.clock.tick( 10 );
 
-});
+} );
 
-test("animate with no properties", function() {
-	expect(2);
+test( "animate with no properties", function() {
+	expect( 2 );
 
 	var foo,
-		divs = jQuery("div"),
+		divs = jQuery( "div" ),
 		count = 0;
 
-	divs.animate({}, function(){
+	divs.animate( {}, function() {
 		count++;
-	});
+	} );
 
 	equal( divs.length, count, "Make sure that callback is called for each element in the set." );
 
+	foo = jQuery( "#foo" );
 
-	foo = jQuery("#foo");
-
-	foo.animate({});
-	foo.animate({top: 10}, 100, function(){
+	foo.animate( {} );
+	foo.animate( { top: 10 }, 100, function() {
 		ok( true, "Animation was properly dequeued." );
-	});
+	} );
 	this.clock.tick( 100 );
-});
-
-test("animate duration 0", function() {
-	expect(11);
+} );
 
+test( "animate duration 0", function() {
+	expect( 11 );
 
 	var $elem,
-		$elems = jQuery([{ a:0 },{ a:0 }]),
+		$elems = jQuery( [ { a:0 }, { a:0 } ] ),
 		counter = 0;
 
 	equal( jQuery.timers.length, 0, "Make sure no animation was running from another test" );
 
-	$elems.eq(0).animate( {a:1}, 0, function(){
+	$elems.eq( 0 ).animate( { a:1 }, 0, function() {
 		ok( true, "Animate a simple property." );
 		counter++;
-	});
+	} );
 
 	// Failed until [6115]
 	equal( jQuery.timers.length, 0, "Make sure synchronic animations are not left on jQuery.timers" );
 
 	equal( counter, 1, "One synchronic animations" );
 
-	$elems.animate( { a:2 }, 0, function(){
+	$elems.animate( { a:2 }, 0, function() {
 		ok( true, "Animate a second simple property." );
 		counter++;
-	});
+	} );
 
 	equal( counter, 3, "Multiple synchronic animations" );
 
-	$elems.eq(0).animate( {a:3}, 0, function(){
+	$elems.eq( 0 ).animate( { a:3 }, 0, function() {
 		ok( true, "Animate a third simple property." );
 		counter++;
-	});
-	$elems.eq(1).animate( {a:3}, 200, function(){
+	} );
+	$elems.eq( 1 ).animate( { a:3 }, 200, function() {
 		counter++;
+
 		// Failed until [6115]
 		equal( counter, 5, "One synchronic and one asynchronic" );
-	});
+	} );
 	this.clock.tick( 200 );
 
-	$elem = jQuery("<div />");
-	$elem.show(0, function(){
-		ok(true, "Show callback with no duration");
-	});
-	$elem.hide(0, function(){
-		ok(true, "Hide callback with no duration");
-	});
+	$elem = jQuery( "<div />" );
+	$elem.show( 0, function() {
+		ok( true, "Show callback with no duration" );
+	} );
+	$elem.hide( 0, function() {
+		ok( true, "Hide callback with no duration" );
+	} );
 
 	// manually clean up detached elements
 	$elem.remove();
-});
+} );
 
-test("animate hyphenated properties", function() {
-	expect(1);
+test( "animate hyphenated properties", function() {
+	expect( 1 );
 
-	jQuery("#foo")
-		.css("font-size", 10)
-		.animate({"font-size": 20}, 200, function() {
+	jQuery( "#foo" )
+		.css( "font-size", 10 )
+		.animate( { "font-size": 20 }, 200, function() {
 			equal( this.style.fontSize, "20px", "The font-size property was animated." );
-		});
+		} );
+
 	// FIXME why is this double only when run with other tests
 	this.clock.tick( 400 );
 
-});
+} );
 
-test("animate non-element", function() {
-	expect(1);
+test( "animate non-element", function() {
+	expect( 1 );
 
 	var obj = { test: 0 };
 
-	jQuery(obj).animate({test: 200}, 200, function(){
+	jQuery( obj ).animate( { test: 200 }, 200, function() {
 		equal( obj.test, 200, "The custom property should be modified." );
-	});
+	} );
 	this.clock.tick( 200 );
-});
+} );
 
-test("stop()", function() {
+test( "stop()", function() {
 	expect( 4 );
 
 	var $one, $two,
-		$foo = jQuery("#foo"),
+		$foo = jQuery( "#foo" ),
 		w = 0,
 		nw;
 
@@ -603,34 +601,35 @@ test("stop()", function() {
 		.animate( { "width": "show" }, 1500 );
 
 	this.clock.tick( 100 );
-	nw = $foo.css("width");
+	nw = $foo.css( "width" );
 	notEqual( parseFloat( nw ), w, "An animation occurred " + nw + " " + w + "px" );
 	$foo.stop();
 
-	nw = $foo.css("width");
+	nw = $foo.css( "width" );
 	notEqual( parseFloat( nw ), w, "Stop didn't reset the animation " + nw + " " + w + "px" );
 
 	this.clock.tick( 100 );
 
 	$foo.removeData();
-	$foo.removeData(undefined, true);
-	equal( nw, $foo.css("width"), "The animation didn't continue" );
+	$foo.removeData( undefined, true );
+	equal( nw, $foo.css( "width" ), "The animation didn't continue" );
 
-	$one = jQuery("#fadein");
-	$two = jQuery("#show");
-	$one.fadeTo(100, 0, function() {
+	$one = jQuery( "#fadein" );
+	$two = jQuery( "#show" );
+	$one.fadeTo( 100, 0, function() {
 		$one.stop();
-	});
+	} );
 	this.clock.tick( 100 );
-	$two.fadeTo(100, 0, function() {
-		equal( $two.css("opacity"), "0", "Stop does not interfere with animations on other elements (#6641)" );
+	$two.fadeTo( 100, 0, function() {
+		equal( $two.css( "opacity" ), "0", "Stop does not interfere with animations on other elements (#6641)" );
+
 		// Reset styles
-		$one.add( $two ).css("opacity", "");
-	});
+		$one.add( $two ).css( "opacity", "" );
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("stop() - several in queue", function() {
+test( "stop() - several in queue", function() {
 	expect( 5 );
 
 	var nw, $foo = jQuery( "#foo" );
@@ -638,9 +637,9 @@ test("stop() - several in queue", function() {
 	// default duration is 400ms, so 800px ensures we aren't 0 or 1 after 1ms
 	$foo.hide().css( "width", 800 );
 
-	$foo.animate({ "width": "show" }, 400, "linear");
-	$foo.animate({ "width": "hide" });
-	$foo.animate({ "width": "show" });
+	$foo.animate( { "width": "show" }, 400, "linear" );
+	$foo.animate( { "width": "hide" } );
+	$foo.animate( { "width": "show" } );
 
 	this.clock.tick( 1 );
 
@@ -658,117 +657,119 @@ test("stop() - several in queue", function() {
 	$foo.stop( true );
 
 	equal( $foo.queue().length, 0, "0 in the queue" );
-});
+} );
 
-test("stop(clearQueue)", function() {
-	expect(4);
+test( "stop(clearQueue)", function() {
+	expect( 4 );
 
-	var $foo = jQuery("#foo"),
+	var $foo = jQuery( "#foo" ),
 		w = 0,
 		nw;
-	$foo.hide().css( "width", 200 ).css("width");
+	$foo.hide().css( "width", 200 ).css( "width" );
 
-	$foo.animate({ "width": "show" }, 1000);
-	$foo.animate({ "width": "hide" }, 1000);
-	$foo.animate({ "width": "show" }, 1000);
+	$foo.animate( { "width": "show" }, 1000 );
+	$foo.animate( { "width": "hide" }, 1000 );
+	$foo.animate( { "width": "show" }, 1000 );
 	this.clock.tick( 100 );
-	nw = $foo.css("width");
-	ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px");
-	$foo.stop(true);
+	nw = $foo.css( "width" );
+	ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px" );
+	$foo.stop( true );
 
-	nw = $foo.css("width");
-	ok( parseFloat( nw ) !== w, "Stop didn't reset the animation " + nw + " " + w + "px");
+	nw = $foo.css( "width" );
+	ok( parseFloat( nw ) !== w, "Stop didn't reset the animation " + nw + " " + w + "px" );
 
 	equal( $foo.queue().length, 0, "The animation queue was cleared" );
 	this.clock.tick( 100 );
-	equal( nw, $foo.css("width"), "The animation didn't continue" );
-});
+	equal( nw, $foo.css( "width" ), "The animation didn't continue" );
+} );
 
-test("stop(clearQueue, gotoEnd)", function() {
-	expect(1);
+test( "stop(clearQueue, gotoEnd)", function() {
+	expect( 1 );
 
-	var $foo = jQuery("#foo"),
+	var $foo = jQuery( "#foo" ),
 		w = 0,
 		nw;
-	$foo.hide().css( "width", 200 ).css("width");
+	$foo.hide().css( "width", 200 ).css( "width" );
 
-	$foo.animate({ width: "show" }, 1000);
-	$foo.animate({ width: "hide" }, 1000);
-	$foo.animate({ width: "show" }, 1000);
-	$foo.animate({ width: "hide" }, 1000);
+	$foo.animate( { width: "show" }, 1000 );
+	$foo.animate( { width: "hide" }, 1000 );
+	$foo.animate( { width: "show" }, 1000 );
+	$foo.animate( { width: "hide" }, 1000 );
 	this.clock.tick( 100 );
-	nw = $foo.css("width");
-	ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px");
-	$foo.stop(false, true);
+	nw = $foo.css( "width" );
+	ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px" );
+	$foo.stop( false, true );
+
+	nw = $foo.css( "width" );
 
-	nw = $foo.css("width");
 	// Disabled, being flaky
 	//equal( nw, 1, "Stop() reset the animation" );
 
 	this.clock.tick( 100 );
+
 	// Disabled, being flaky
 	//equal( $foo.queue().length, 2, "The next animation continued" );
-	$foo.stop(true);
-});
+	$foo.stop( true );
+} );
 
 test( "stop( queue, ..., ... ) - Stop single queues", function() {
 	expect( 3 );
 	var saved,
-		foo = jQuery("#foo").css({ width: 200, height: 200 });
+		foo = jQuery( "#foo" ).css( { width: 200, height: 200 } );
 
-	foo.animate({
+	foo.animate( {
 		width: 400
-	},{
+	}, {
 		duration: 500,
 		complete: function() {
-			equal( parseFloat( foo.css("width") ), 400, "Animation completed for standard queue" );
-			equal( parseFloat( foo.css("height") ), saved, "Height was not changed after the second stop");
+			equal( parseFloat( foo.css( "width" ) ), 400, "Animation completed for standard queue" );
+			equal( parseFloat( foo.css( "height" ) ), saved, "Height was not changed after the second stop" );
 		}
-	});
+	} );
 
-	foo.animate({
+	foo.animate( {
 		height: 400
-	},{
+	}, {
 		duration: 1000,
 		queue: "height"
-	}).dequeue("height").stop( "height", false, true );
+	} ).dequeue( "height" ).stop( "height", false, true );
 
-	equal( parseFloat( foo.css("height") ), 400, "Height was stopped with gotoEnd" );
+	equal( parseFloat( foo.css( "height" ) ), 400, "Height was stopped with gotoEnd" );
 
-	foo.animate({
+	foo.animate( {
 		height: 200
-	},{
+	}, {
 		duration: 1000,
 		queue: "height"
-	}).dequeue( "height" ).stop( "height", false, false );
-	saved = parseFloat( foo.css("height") );
+	} ).dequeue( "height" ).stop( "height", false, false );
+	saved = parseFloat( foo.css( "height" ) );
         this.clock.tick( 500 );
-});
+} );
 
-test("toggle()", function() {
-	expect(6);
-	var x = jQuery("#foo");
-	ok( x.is(":visible"), "is visible" );
+test( "toggle()", function() {
+	expect( 6 );
+	var x = jQuery( "#foo" );
+	ok( x.is( ":visible" ), "is visible" );
 	x.toggle();
-	ok( x.is(":hidden"), "is hidden" );
+	ok( x.is( ":hidden" ), "is hidden" );
 	x.toggle();
-	ok( x.is(":visible"), "is visible again" );
-
-	x.toggle(true);
-	ok( x.is(":visible"), "is visible" );
-	x.toggle(false);
-	ok( x.is(":hidden"), "is hidden" );
-	x.toggle(true);
-	ok( x.is(":visible"), "is visible again" );
-});
+	ok( x.is( ":visible" ), "is visible again" );
+
+	x.toggle( true );
+	ok( x.is( ":visible" ), "is visible" );
+	x.toggle( false );
+	ok( x.is( ":hidden" ), "is hidden" );
+	x.toggle( true );
+	ok( x.is( ":visible" ), "is visible again" );
+} );
 
 test( "jQuery.fx.prototype.cur() - <1.8 Back Compat", 7, function() {
-	var div = jQuery( "<div></div>" ).appendTo( "#qunit-fixture" ).css({
+	var div = jQuery( "<div></div>" ).appendTo( "#qunit-fixture" ).css( {
 			color: "#ABC",
 			border: "5px solid black",
 			left: "auto",
 			marginBottom: "-11000px"
-		})[0];
+		} )[ 0 ];
 
 	equal(
 		( new jQuery.fx( div, {}, "color" ) ).cur(),
@@ -814,31 +815,31 @@ test( "jQuery.fx.prototype.cur() - <1.8 Back Compat", 7, function() {
 	);
 
 	jQuery( div ).remove();
-});
+} );
 
-test("Overflow and Display", function() {
-	expect(4);
+test( "Overflow and Display", function() {
+	expect( 4 );
 
 	var
-		testClass = jQuery.makeTest("Overflow and Display")
-			.addClass("overflow inline"),
-		testStyle = jQuery.makeTest("Overflow and Display (inline style)")
-			.css({ overflow: "visible", display: "inline" }),
+		testClass = jQuery.makeTest( "Overflow and Display" )
+			.addClass( "overflow inline" ),
+		testStyle = jQuery.makeTest( "Overflow and Display (inline style)" )
+			.css( { overflow: "visible", display: "inline" } ),
 		done = function() {
 			equal( jQuery.css( this, "overflow" ), "visible", "Overflow should be 'visible'" );
 			equal( jQuery.css( this, "display" ), "inline", "Display should be 'inline'" );
 		};
 
 	testClass.add( testStyle )
-		.addClass("widewidth")
-		.text("Some sample text.")
-		.before("text before")
-		.after("text after")
-		.animate({ opacity: 0.5 }, "slow", done );
+		.addClass( "widewidth" )
+		.text( "Some sample text." )
+		.before( "text before" )
+		.after( "text after" )
+		.animate( { opacity: 0.5 }, "slow", done );
 	this.clock.tick( 600 );
-});
+} );
 
-jQuery.each({
+jQuery.each( {
 	"CSS Auto": function( elem, prop ) {
 		jQuery( elem ).addClass( "auto" + prop )
 			.text( "This is a long string of text." );
@@ -874,7 +875,7 @@ jQuery.each({
 		return 0;
 	}
 }, function( fn, f ) {
-	jQuery.each({
+	jQuery.each( {
 		"show": function( elem, prop ) {
 			jQuery( elem ).hide( ).addClass( "wide" + prop );
 			return "show";
@@ -895,7 +896,7 @@ jQuery.each({
 			return 0;
 		}
 	}, function( tn, t ) {
-		test(fn + " to " + tn, function() {
+		test( fn + " to " + tn, function() {
 			var num, anim,
 				elem = jQuery.makeTest( fn + " to " + tn ),
 				t_w = t( elem, "width" ),
@@ -910,6 +911,7 @@ jQuery.each({
 			}
 
 			num = 0;
+
 			// TODO: uncrowd this
 			if ( t_h === "show" ) {num++;}
 			if ( t_w === "show" ) {num++;}
@@ -919,15 +921,15 @@ jQuery.each({
 			if ( t_w === "hide" ) {num++;}
 			if ( t_o.constructor === Number ) {num += 2;}
 			if ( t_w.constructor === Number ) {num += 2;}
-			if ( t_h.constructor === Number ) {num +=2;}
+			if ( t_h.constructor === Number ) {num += 2;}
 
 			expect( num );
 
 			anim = { width: t_w, height: t_h, opacity: t_o };
 
-			elem.animate(anim, 50);
+			elem.animate( anim, 50 );
 
-			jQuery.when( elem ).done(function( elem ) {
+			jQuery.when( elem ).done( function( elem ) {
 				var cur_o, cur_w, cur_h, old_h;
 
 				elem = elem[ 0 ];
@@ -944,9 +946,9 @@ jQuery.each({
 					ok( f_h === "" ? elem.style.height === f_h : elem.style.height.indexOf( f_h ) === 0, "Height must be reset to " + f_h + ": " + elem.style.height );
 				}
 
-				cur_o = jQuery.style(elem, "opacity");
+				cur_o = jQuery.style( elem, "opacity" );
 
-				if ( f_o !== jQuery.css(elem, "opacity") ) {
+				if ( f_o !== jQuery.css( elem, "opacity" ) ) {
 					f_o = f( elem, "opacity" );
 				}
 
@@ -955,6 +957,7 @@ jQuery.each({
 				if ( f_o === "" ) {
 					f_o = 1;
 				}
+
 				// See above
 				if ( cur_o === "" ) {
 					cur_o = 1;
@@ -971,13 +974,13 @@ jQuery.each({
 				if ( t_o.constructor === Number ) {
 					equal( cur_o, t_o, "Final opacity should be " + t_o + ": " + cur_o );
 
-					ok( jQuery.css(elem, "opacity") !== "" || cur_o === t_o, "Opacity should be explicitly set to " + t_o + ", is instead: " + cur_o );
+					ok( jQuery.css( elem, "opacity" ) !== "" || cur_o === t_o, "Opacity should be explicitly set to " + t_o + ", is instead: " + cur_o );
 				}
 
 				if ( t_w.constructor === Number ) {
 					equal( elem.style.width, t_w + "px", "Final width should be " + t_w + ": " + elem.style.width );
 
-					cur_w = jQuery.css( elem,"width" );
+					cur_w = jQuery.css( elem, "width" );
 
 					ok( elem.style.width !== "" || cur_w === t_w, "Width should be explicitly set to " + t_w + ", is instead: " + cur_w );
 				}
@@ -985,14 +988,14 @@ jQuery.each({
 				if ( t_h.constructor === Number ) {
 					equal( elem.style.height, t_h + "px", "Final height should be " + t_h + ": " + elem.style.height );
 
-					cur_h = jQuery.css( elem,"height" );
+					cur_h = jQuery.css( elem, "height" );
 
 					ok( elem.style.height !== "" || cur_h === t_h, "Height should be explicitly set to " + t_h + ", is instead: " + cur_h );
 				}
 
 				if ( t_h === "show" ) {
 					old_h = jQuery.css( elem, "height" );
-					jQuery( elem ).append("<br/>Some more text<br/>and some more...");
+					jQuery( elem ).append( "<br/>Some more text<br/>and some more..." );
 
 					if ( /Auto/.test( fn ) ) {
 						notEqual( jQuery.css( elem, "height" ), old_h, "Make sure height is auto." );
@@ -1004,18 +1007,18 @@ jQuery.each({
 				// manually remove generated element
 				jQuery( elem ).remove();
 
-			});
+			} );
 			this.clock.tick( 50 );
-		});
-	});
-});
+		} );
+	} );
+} );
 
-test("Effects chaining", function() {
+test( "Effects chaining", function() {
 	var remaining = 16,
 		props = [ "opacity", "height", "width", "display", "overflow" ],
 		setup = function( name, selector ) {
 			var $el = jQuery( selector );
-			return $el.data( getProps( $el[0] ) ).data( "name", name );
+			return $el.data( getProps( $el[ 0 ] ) ).data( "name", name );
 		},
 		assert = function() {
 			var data = jQuery.data( this ),
@@ -1030,39 +1033,39 @@ test("Effects chaining", function() {
 			var obj = {};
 			jQuery.each( props, function( i, prop ) {
 				obj[ prop ] = prop === "overflow" && hiddenOverflow ? "hidden" : el.style[ prop ] || jQuery.css( el, prop );
-			});
+			} );
 			return obj;
 		};
 
 	expect( remaining );
 
-	setup( ".fadeOut().fadeIn()", "#fadein div" ).fadeOut("fast").fadeIn( "fast", assert );
-	setup( ".fadeIn().fadeOut()", "#fadeout div" ).fadeIn("fast").fadeOut( "fast", assert );
-	setup( ".hide().show()", "#show div" ).hide("fast").show( "fast", assert );
-	setup( ".show().hide()", "#hide div" ).show("fast").hide( "fast", assert );
-	setup( ".show().hide(easing)", "#easehide div" ).show("fast").hide( "fast", "linear", assert );
-	setup( ".toggle().toggle() - in", "#togglein div" ).toggle("fast").toggle( "fast", assert );
-	setup( ".toggle().toggle() - out", "#toggleout div" ).toggle("fast").toggle( "fast", assert );
-	setup( ".toggle().toggle(easing) - out", "#easetoggleout div" ).toggle("fast").toggle( "fast", "linear", assert );
-	setup( ".slideDown().slideUp()", "#slidedown div" ).slideDown("fast").slideUp( "fast", assert );
-	setup( ".slideUp().slideDown()", "#slideup div" ).slideUp("fast").slideDown( "fast", assert );
-	setup( ".slideUp().slideDown(easing)", "#easeslideup div" ).slideUp("fast").slideDown( "fast", "linear", assert );
-	setup( ".slideToggle().slideToggle() - in", "#slidetogglein div" ).slideToggle("fast").slideToggle( "fast", assert );
-	setup( ".slideToggle().slideToggle() - out", "#slidetoggleout div" ).slideToggle("fast").slideToggle( "fast", assert );
-	setup( ".fadeToggle().fadeToggle() - in", "#fadetogglein div" ).fadeToggle("fast").fadeToggle( "fast", assert );
-	setup( ".fadeToggle().fadeToggle() - out", "#fadetoggleout div" ).fadeToggle("fast").fadeToggle( "fast", assert );
+	setup( ".fadeOut().fadeIn()", "#fadein div" ).fadeOut( "fast" ).fadeIn( "fast", assert );
+	setup( ".fadeIn().fadeOut()", "#fadeout div" ).fadeIn( "fast" ).fadeOut( "fast", assert );
+	setup( ".hide().show()", "#show div" ).hide( "fast" ).show( "fast", assert );
+	setup( ".show().hide()", "#hide div" ).show( "fast" ).hide( "fast", assert );
+	setup( ".show().hide(easing)", "#easehide div" ).show( "fast" ).hide( "fast", "linear", assert );
+	setup( ".toggle().toggle() - in", "#togglein div" ).toggle( "fast" ).toggle( "fast", assert );
+	setup( ".toggle().toggle() - out", "#toggleout div" ).toggle( "fast" ).toggle( "fast", assert );
+	setup( ".toggle().toggle(easing) - out", "#easetoggleout div" ).toggle( "fast" ).toggle( "fast", "linear", assert );
+	setup( ".slideDown().slideUp()", "#slidedown div" ).slideDown( "fast" ).slideUp( "fast", assert );
+	setup( ".slideUp().slideDown()", "#slideup div" ).slideUp( "fast" ).slideDown( "fast", assert );
+	setup( ".slideUp().slideDown(easing)", "#easeslideup div" ).slideUp( "fast" ).slideDown( "fast", "linear", assert );
+	setup( ".slideToggle().slideToggle() - in", "#slidetogglein div" ).slideToggle( "fast" ).slideToggle( "fast", assert );
+	setup( ".slideToggle().slideToggle() - out", "#slidetoggleout div" ).slideToggle( "fast" ).slideToggle( "fast", assert );
+	setup( ".fadeToggle().fadeToggle() - in", "#fadetogglein div" ).fadeToggle( "fast" ).fadeToggle( "fast", assert );
+	setup( ".fadeToggle().fadeToggle() - out", "#fadetoggleout div" ).fadeToggle( "fast" ).fadeToggle( "fast", assert );
 	setup( ".fadeTo(0.5).fadeTo(1.0, easing)", "#fadeto div" ).fadeTo( "fast", 0.5 ).fadeTo( "fast", 1.0, "linear", assert );
         this.clock.tick( 400 );
-});
+} );
 
-jQuery.makeTest = function( text ){
-        var elem = jQuery("<div></div>")
+jQuery.makeTest = function( text ) {
+        var elem = jQuery( "<div></div>" )
                 .attr( "id", "test" + jQuery.makeTest.id++ )
-                .addClass("box");
+                .addClass( "box" );
 
-        jQuery("<h4></h4>")
+        jQuery( "<h4></h4>" )
                 .text( text )
-                .appendTo("#fx-tests")
+                .appendTo( "#fx-tests" )
                 .after( elem );
 
         return elem;
@@ -1070,18 +1073,18 @@ jQuery.makeTest = function( text ){
 
 jQuery.makeTest.id = 1;
 
-test("jQuery.show('fast') doesn't clear radio buttons (bug #1095)", function () {
-	expect(4);
+test( "jQuery.show('fast') doesn't clear radio buttons (bug #1095)", function() {
+	expect( 4 );
 
-	var $checkedtest = jQuery("#checkedtest");
-	$checkedtest.hide().show("fast", function() {
-		ok( jQuery("input[type='radio']", $checkedtest).first().attr("checked"), "Check first radio still checked." );
-		ok( !jQuery("input[type='radio']", $checkedtest).last().attr("checked"), "Check last radio still NOT checked." );
-		ok( jQuery("input[type='checkbox']", $checkedtest).first().attr("checked"), "Check first checkbox still checked." );
-		ok( !jQuery("input[type='checkbox']", $checkedtest).last().attr("checked"), "Check last checkbox still NOT checked." );
-	});
+	var $checkedtest = jQuery( "#checkedtest" );
+	$checkedtest.hide().show( "fast", function() {
+		ok( jQuery( "input[type='radio']", $checkedtest ).first().attr( "checked" ), "Check first radio still checked." );
+		ok( !jQuery( "input[type='radio']", $checkedtest ).last().attr( "checked" ), "Check last radio still NOT checked." );
+		ok( jQuery( "input[type='checkbox']", $checkedtest ).first().attr( "checked" ), "Check first checkbox still checked." );
+		ok( !jQuery( "input[type='checkbox']", $checkedtest ).last().attr( "checked" ), "Check last checkbox still NOT checked." );
+	} );
 	this.clock.tick( 200 );
-});
+} );
 
 test( "interrupt toggle", function() {
 	expect( 24 );
@@ -1090,13 +1093,14 @@ test( "interrupt toggle", function() {
 		longDuration = 2000,
 		shortDuration = 500,
 		remaining = 0,
-		$elems = jQuery(".chain-test"),
+		$elems = jQuery( ".chain-test" ),
 		clock = this.clock,
 		finish = function() {
 		};
 
 	jQuery.each( { slideToggle: "height", fadeToggle: "opacity", toggle: "width" }, function( method, prop ) {
-		var $methodElems = $elems.filter( "[id^='" + method.toLowerCase() + "']" ).each(function() {
+		var $methodElems = $elems.filter( "[id^='" + method.toLowerCase() + "']" ).each( function() {
+
 			// Don't end test until we're done with this element
 			remaining++;
 
@@ -1105,28 +1109,28 @@ test( "interrupt toggle", function() {
 
 			// Expect olddisplay data from our .hide() call below
 			QUnit.expectJqData( env, this, "olddisplay" );
-		});
+		} );
 
 		// Interrupt a hiding toggle
 		$methodElems[ method ]( longDuration );
-		setTimeout(function() {
-			$methodElems.stop().each(function() {
+		setTimeout( function() {
+			$methodElems.stop().each( function() {
 				notEqual( jQuery( this ).css( prop ), jQuery.data( this, "startVal" ), ".stop() before completion of hiding ." + method + "() - #" + this.id );
-			});
+			} );
 
 			// Restore
 			$methodElems[ method ]( shortDuration, function() {
 				var id = this.id,
 					$elem = jQuery( this ),
-					startVal = $elem.data("startVal");
+					startVal = $elem.data( "startVal" );
 
-				$elem.removeData("startVal");
+				$elem.removeData( "startVal" );
 
 				equal( $elem.css( prop ), startVal, "original value restored by ." + method + "() - #" + id );
 
 				// Interrupt a showing toggle
 				$elem.hide()[ method ]( longDuration );
-				setTimeout(function() {
+				setTimeout( function() {
 					$elem.stop();
 					notEqual( $elem.css( prop ), startVal, ".stop() before completion of showing ." + method + "() - #" + id );
 
@@ -1134,15 +1138,15 @@ test( "interrupt toggle", function() {
 					$elem[ method ]( shortDuration, function() {
 						equal( $elem.css( prop ), startVal, "original value restored by ." + method + "() - #" + id );
 						finish();
-					});
+					} );
 				}, shortDuration );
-			});
+			} );
 		}, shortDuration );
-	});
+	} );
 	clock.tick( longDuration );
 
 	// FIXME untangle the set timeouts
-});
+} );
 
 test( "animate with per-property easing", function() {
 
@@ -1179,34 +1183,34 @@ test( "animate with per-property easing", function() {
 		ok( defaultTestCalled, "Easing function (_default) called" );
 		equal( props.a[ 1 ], "_test1", "animate does not change original props (per-property easing would be lost)" );
 		equal( props.b[ 1 ], "_test2", "animate does not change original props (per-property easing would be lost)" );
-	});
+	} );
 
 	this.clock.tick( 400 );
-});
+} );
 
-test("animate with CSS shorthand properties", function(){
-	expect(11);
+test( "animate with CSS shorthand properties", function() {
+	expect( 11 );
 
 	var easeAnimation_count = 0,
 		easeProperty_count = 0,
 		propsBasic = { "padding": "10 20 30" },
 		propsSpecial = { "padding": [ "1 2 3", "propertyScope" ] };
 
-	jQuery.easing.animationScope = function(p) {
+	jQuery.easing.animationScope = function( p ) {
 		if ( p >= 1 ) {
 			easeAnimation_count++;
 		}
 		return p;
 	};
 
-	jQuery.easing.propertyScope = function(p) {
+	jQuery.easing.propertyScope = function( p ) {
 		if ( p >= 1 ) {
 			easeProperty_count++;
 		}
 		return p;
 	};
 
-	jQuery("#foo")
+	jQuery( "#foo" )
 		.animate( propsBasic, 200, "animationScope", function() {
 			equal( this.style.paddingTop, "10px", "padding-top was animated" );
 			equal( this.style.paddingLeft, "20px", "padding-left was animated" );
@@ -1214,7 +1218,7 @@ test("animate with CSS shorthand properties", function(){
 			equal( this.style.paddingBottom, "30px", "padding-bottom was animated" );
 			equal( easeAnimation_count, 4, "per-animation default easing called for each property" );
 			easeAnimation_count = 0;
-		})
+		} )
 		.animate( propsSpecial, 200, "animationScope", function() {
 			equal( this.style.paddingTop, "1px", "padding-top was animated again" );
 			equal( this.style.paddingLeft, "2px", "padding-left was animated again" );
@@ -1223,36 +1227,35 @@ test("animate with CSS shorthand properties", function(){
 			equal( easeAnimation_count, 0, "per-animation default easing not called" );
 			equal( easeProperty_count, 4, "special easing called for each property" );
 
-			jQuery(this).css("padding", "0");
+			jQuery( this ).css( "padding", "0" );
 			delete jQuery.easing.animationScope;
 			delete jQuery.easing.propertyScope;
-		});
+		} );
 		this.clock.tick( 400 );
-});
-
-test("hide hidden elements, with animation (bug #7141)", function() {
-	expect(3);
+} );
 
+test( "hide hidden elements, with animation (bug #7141)", function() {
+	expect( 3 );
 
-	var div = jQuery("<div style='display:none'></div>").appendTo("#qunit-fixture");
-	equal( div.css("display"), "none", "Element is hidden by default" );
-	div.hide(1, function () {
-		ok( !jQuery._data(div, "olddisplay"), "olddisplay is undefined after hiding an already-hidden element" );
-		div.show(1, function () {
-			equal( div.css("display"), "block", "Show a double-hidden element" );
-		});
-	});
+	var div = jQuery( "<div style='display:none'></div>" ).appendTo( "#qunit-fixture" );
+	equal( div.css( "display" ), "none", "Element is hidden by default" );
+	div.hide( 1, function() {
+		ok( !jQuery._data( div, "olddisplay" ), "olddisplay is undefined after hiding an already-hidden element" );
+		div.show( 1, function() {
+			equal( div.css( "display" ), "block", "Show a double-hidden element" );
+		} );
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
-test("animate unit-less properties (#4966)", 2, function() {
+test( "animate unit-less properties (#4966)", 2, function() {
 	var div = jQuery( "<div style='z-index: 0; position: absolute;'></div>" ).appendTo( "#qunit-fixture" );
 	equal( div.css( "z-index" ), "0", "z-index is 0" );
-	div.animate({ zIndex: 2 }, function() {
+	div.animate( { zIndex: 2 }, function() {
 		equal( div.css( "z-index" ), "2", "z-index is 2" );
-	});
+	} );
 	this.clock.tick( 400 );
-});
+} );
 
 test( "animate properties missing px w/ opacity as last (#9074)", 2, function() {
 	expect( 6 );
@@ -1264,11 +1267,11 @@ test( "animate properties missing px w/ opacity as last (#9074)", 2, function()
 	}
 	equal( cssInt( "marginLeft" ), 0, "Margin left is 0" );
 	equal( cssInt( "left" ), 0, "Left is 0" );
-	div.animate({
+	div.animate( {
 		left: 200,
 		marginLeft: 200,
 		opacity: 0
-	}, 2000);
+	}, 2000 );
 
 	this.clock.tick( 500 );
 
@@ -1279,26 +1282,27 @@ test( "animate properties missing px w/ opacity as last (#9074)", 2, function()
 	notEqual( l, 0, "Left is not 0 after partial animate" );
 	notEqual( l, 200, "Left is not 200 after partial animate" );
 	div.stop().remove();
-});
+} );
 
-test("callbacks should fire in correct order (#9100)", function() {
+test( "callbacks should fire in correct order (#9100)", function() {
 	expect( 1 );
 
 	var a = 1,
 		cb = 0;
 
-	jQuery("<p data-operation='*2'></p><p data-operation='^2'></p>")
-		.appendTo("#qunit-fixture")
+	jQuery( "<p data-operation='*2'></p><p data-operation='^2'></p>" )
+		.appendTo( "#qunit-fixture" )
+
 		// The test will always pass if no properties are animated or if the duration is 0
-		.animate({ fontSize: 12 }, 13, function() {
-			a *= jQuery(this).data("operation") === "*2" ? 2 : a;
+		.animate( { fontSize: 12 }, 13, function() {
+			a *= jQuery( this ).data( "operation" ) === "*2" ? 2 : a;
 			cb++;
 			if ( cb === 2 ) {
-				equal( a, 4, "test value has been *2 and _then_ ^2");
+				equal( a, 4, "test value has been *2 and _then_ ^2" );
 			}
-		});
+		} );
 	this.clock.tick( 20 );
-});
+} );
 
 test( "callbacks that throw exceptions will be removed (#5684)", function() {
 	expect( 2 );
@@ -1308,9 +1312,9 @@ test( "callbacks that throw exceptions will be removed (#5684)", function() {
 	function TestException() {
 	}
 
-	foo.animate({ height: 1 }, 1, function() {
+	foo.animate( { height: 1 }, 1, function() {
 		throw new TestException();
-	});
+	} );
 
 	// this test thoroughly abuses undocumented methods - please feel free to update
 	// with any changes internally to these functions.
@@ -1326,37 +1330,38 @@ test( "callbacks that throw exceptions will be removed (#5684)", function() {
 
 	ok( true, "Test completed without throwing a second exception" );
 
-});
+} );
 
-test("animate will scale margin properties individually", function() {
+test( "animate will scale margin properties individually", function() {
 	expect( 2 );
 
-	var foo = jQuery( "#foo" ).css({
+	var foo = jQuery( "#foo" ).css( {
 		"margin": 0,
 		"marginLeft": 100
-	});
+	} );
 
 	ok( foo.css( "marginLeft" ) !== foo.css( "marginRight" ), "Sanity Check" );
 
-	foo.animate({
+	foo.animate( {
 		"margin": 200
-	}).stop();
+	} ).stop();
 
-	ok( foo.css( "marginLeft") !== foo.css( "marginRight" ), "The margin properties are different");
+	ok( foo.css( "marginLeft" ) !== foo.css( "marginRight" ), "The margin properties are different" );
 
 	// clean up for next test
-	foo.css({
+	foo.css( {
 		"marginLeft": "",
 		"marginRight": "",
 		"marginTop": "",
 		"marginBottom": ""
-	});
-});
+	} );
+} );
+
+test( "Do not append px to 'fill-opacity' #9548", 1, function() {
+	var $div = jQuery( "<div>" ).appendTo( "#qunit-fixture" );
 
-test("Do not append px to 'fill-opacity' #9548", 1, function() {
-	var $div = jQuery("<div>").appendTo("#qunit-fixture");
+	$div.css( "fill-opacity", 0 ).animate( { "fill-opacity": 1.0 }, 0, function() {
 
-	$div.css("fill-opacity", 0).animate({ "fill-opacity": 1.0 }, 0, function () {
 		// Support: Android 2.3 (no support for fill-opacity)
 		if ( jQuery( this ).css( "fill-opacity" ) ) {
 			equal( jQuery( this ).css( "fill-opacity" ), 1, "Do not append px to 'fill-opacity'" );
@@ -1364,10 +1369,10 @@ test("Do not append px to 'fill-opacity' #9548", 1, function() {
 			ok( true, "No support for fill-opacity CSS property" );
 		}
 		$div.remove();
-	});
-});
+	} );
+} );
 
-test("line-height animates correctly (#13855)", 12, function() {
+test( "line-height animates correctly (#13855)", 12, function() {
 	var t0,
 		clock = this.clock,
 		longDuration = 2000,
@@ -1377,22 +1382,22 @@ test("line-height animates correctly (#13855)", 12, function() {
 			"<p style='line-height: 5000px;'>px</p>" +
 			"<p style='line-height: 5000%;'>percent</p>" +
 			"<p style='line-height: 100em;'>em</p>"
-		).appendTo("#qunit-fixture"),
+		).appendTo( "#qunit-fixture" ),
 		initialHeight = jQuery.map( animated, function( el ) {
 			return jQuery( el ).height();
-		}),
+		} ),
 		tolerance = 1.5;
 
 	// Delay start to improve test stability
-	setTimeout(function() {
+	setTimeout( function() {
 
-		t0 = +(new Date());
+		t0 = +( new Date() );
 		animated.animate( { "line-height": "hide" }, longDuration, "linear" );
 
-		setTimeout(function() {
-			var progress = ( (new Date()) - t0 ) / longDuration;
+		setTimeout( function() {
+			var progress = ( ( new Date() ) - t0 ) / longDuration;
 
-			animated.each(function( i ) {
+			animated.each( function( i ) {
 				var label = jQuery.text( this ),
 					initial = initialHeight[ i ],
 					height = jQuery( this ).height(),
@@ -1401,32 +1406,32 @@ test("line-height animates correctly (#13855)", 12, function() {
 					height + " < " + initial + " @ " + ( progress * 100 ) + "%" );
 				ok( height > lower, "hide " + label + ": lower bound; "  +
 					height + " > " + lower + " @ " + ( progress * 100 ) + "%" );
-			});
+			} );
 
-			t0 = +(new Date());
+			t0 = +( new Date() );
 			animated.stop( true, true ).hide()
 					.animate( { "line-height": "show" }, longDuration, "linear" );
 
-			setTimeout(function() {
-				var progress = ( (new Date()) - t0 ) / longDuration;
+			setTimeout( function() {
+				var progress = ( ( new Date() ) - t0 ) / longDuration;
 
-				animated.each(function( i ) {
+				animated.each( function( i ) {
 					var label = jQuery.text( this ),
 						initial = initialHeight[ i ],
 						height = jQuery( this ).height(),
 						upper = initial * progress * tolerance;
 					ok( height < upper, "show " + label + ": upper bound; " +
 						height + " < " + upper + " @ " + ( progress * 100 ) + "%" );
-				});
+				} );
 
 				animated.stop( true, true );
 			}, shortDuration );
-clock.tick(shortDuration);
+clock.tick( shortDuration );
 		}, shortDuration );
-clock.tick(shortDuration);
+clock.tick( shortDuration );
 	}, 50 );
 clock.tick( 50 );
-});
+} );
 
 // Start 1.8 Animation tests
 test( "jQuery.Animation( object, props, opts )", 4, function() {
@@ -1442,21 +1447,21 @@ test( "jQuery.Animation( object, props, opts )", 4, function() {
 			"width": 200
 		};
 
-	animation = jQuery.Animation( testObject, testDest, { "duration": 1 });
-	animation.done(function() {
+	animation = jQuery.Animation( testObject, testDest, { "duration": 1 } );
+	animation.done( function() {
 		for ( var prop in testDest ) {
 			equal( testObject[ prop ], testDest[ prop ], "Animated: " + prop );
 		}
-		animation.done(function() {
+		animation.done( function() {
 			deepEqual( testObject, testDest, "No unexpected properties" );
-		});
-	});
+		} );
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 test( "Animate Option: step: function( percent, tween )", 1, function() {
 	var counter = {};
-	jQuery( "#foo" ).animate({
+	jQuery( "#foo" ).animate( {
 		prop1: 1,
 		prop2: 2,
 		prop3: 3
@@ -1464,35 +1469,36 @@ test( "Animate Option: step: function( percent, tween )", 1, function() {
 		duration: 1,
 		step: function( value, tween ) {
 			var calls = counter[ tween.prop ] = counter[ tween.prop ] || [];
+
 			// in case this is called multiple times for either, lets store it in
 			// 0 or 1 in the array
 			calls[ value === 0 ? 0 : 1 ] = value;
 		}
-	}).queue( function( next ) {
+	} ).queue( function( next ) {
 		deepEqual( counter, {
-			prop1: [0, 1],
-			prop2: [0, 2],
-			prop3: [0, 3]
-		}, "Step function was called once at 0% and once at 100% for each property");
+			prop1: [ 0, 1 ],
+			prop2: [ 0, 2 ],
+			prop3: [ 0, 3 ]
+		}, "Step function was called once at 0% and once at 100% for each property" );
 		next();
-	});
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 test( "Animate callbacks have correct context", 2, function() {
 	var foo = jQuery( "#foo" );
-	foo.animate({
+	foo.animate( {
 		height: 10
 	}, 10, function() {
 		equal( foo[ 0 ], this, "Complete callback after stop(true) `this` is element" );
-	}).stop( true, true );
-	foo.animate({
+	} ).stop( true, true );
+	foo.animate( {
 		height: 100
 	}, 10, function() {
 		equal( foo[ 0 ], this, "Complete callback `this` is element" );
-	});
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 test( "User supplied callback called after show when fx off (#8892)", 2, function() {
 	var foo = jQuery( "#foo" );
@@ -1503,10 +1509,10 @@ test( "User supplied callback called after show when fx off (#8892)", 2, functio
 		foo.fadeOut( 500, function() {
 			ok( jQuery( this ).is( ":hidden" ), "Element is hidden in callback" );
 			jQuery.fx.off = false;
-		});
-	});
+		} );
+	} );
 	this.clock.tick( 1000 );
-});
+} );
 
 test( "animate should set display for disconnected nodes", function() {
 	expect( 18 );
@@ -1519,13 +1525,14 @@ test( "animate should set display for disconnected nodes", function() {
 			fadeTo: [ "fast", 0.5 ],
 			slideDown: [ "fast" ],
 			show: [ 1 ],
-			animate: [{ width: "show" }]
+			animate: [ { width: "show" } ]
 		},
-		$divTest = jQuery("<div>test</div>"),
+		$divTest = jQuery( "<div>test</div>" ),
+
 		// parentNode = null
-		$divEmpty = jQuery("<div/>"),
-		$divNone = jQuery("<div style='display: none;'/>"),
-		$divInline = jQuery("<div style='display: inline;'/>"),
+		$divEmpty = jQuery( "<div/>" ),
+		$divNone = jQuery( "<div style='display: none;'/>" ),
+		$divInline = jQuery( "<div style='display: inline;'/>" ),
 		clock = this.clock;
 
 	strictEqual( $divTest.show()[ 0 ].style.display, "block", "set display with show() for element with parentNode = document fragment" );
@@ -1538,56 +1545,56 @@ test( "animate should set display for disconnected nodes", function() {
 	QUnit.expectJqData( env, $divNone[ 0 ], "olddisplay" );
 
 	jQuery.each( methods, function( name, opt ) {
-		jQuery.each([
+		jQuery.each( [
 
 			// parentNode = document fragment
-			jQuery("<div>test</div>"),
+			jQuery( "<div>test</div>" ),
 
 			// parentNode = null
-			jQuery("<div/>")
+			jQuery( "<div/>" )
 
 		], function() {
-			var callback = [function () {
+			var callback = [ function() {
 					strictEqual( this.style.display, "block", "set display to block with " + name );
 
 					QUnit.expectJqData( env, this, "olddisplay" );
 
-			}];
+			} ];
 			jQuery.fn[ name ].apply( this, opt.concat( callback ) );
-		});
-	});
+		} );
+	} );
         clock.tick( 400 );
-});
+} );
 
-test("Animation callback should not show animated element as :animated (#7157)", 1, function() {
+test( "Animation callback should not show animated element as :animated (#7157)", 1, function() {
 	var foo = jQuery( "#foo" );
 
-	foo.animate({
+	foo.animate( {
 		opacity: 0
 	}, 100, function() {
-		ok( !foo.is(":animated"), "The element is not animated" );
-	});
+		ok( !foo.is( ":animated" ), "The element is not animated" );
+	} );
 	this.clock.tick( 100 );
-});
+} );
 
-test("Initial step callback should show element as :animated (#14623)", 1, function() {
+test( "Initial step callback should show element as :animated (#14623)", 1, function() {
 	var foo = jQuery( "#foo" );
 
-	foo.animate({
+	foo.animate( {
 		opacity: 0
 	}, {
 		duration: 100,
 		step: function() {
-			ok( foo.is(":animated"), "The element matches :animated inside step function" );
+			ok( foo.is( ":animated" ), "The element matches :animated inside step function" );
 		}
-	});
+	} );
 	this.clock.tick( 1 );
 	foo.stop();
-});
+} );
 
 test( "hide called on element within hidden parent should set display to none (#10045)", 3, function() {
-	var hidden = jQuery(".hidden"),
-		elems = jQuery("<div>hide</div><div>hide0</div><div>hide1</div>");
+	var hidden = jQuery( ".hidden" ),
+		elems = jQuery( "<div>hide</div><div>hide0</div><div>hide1</div>" );
 
 	hidden.append( elems );
 
@@ -1595,23 +1602,23 @@ test( "hide called on element within hidden parent should set display to none (#
 		elems.eq( 0 ).hide(),
 		elems.eq( 1 ).hide( 0 ),
 		elems.eq( 2 ).hide( 1 )
-	).done(function() {
+	).done( function() {
 		strictEqual( elems.get( 0 ).style.display, "none", "hide() called on element within hidden parent should set display to none" );
 		strictEqual( elems.get( 1 ).style.display, "none", "hide( 0 ) called on element within hidden parent should set display to none" );
 		strictEqual( elems.get( 2 ).style.display, "none", "hide( 1 ) called on element within hidden parent should set display to none" );
 
 		elems.remove();
-	});
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 test( "hide, fadeOut and slideUp called on element width height and width = 0 should set display to none", 5, function() {
-	var foo = jQuery("#foo"),
+	var foo = jQuery( "#foo" ),
 		i = 0,
 		elems = jQuery();
 
 	for ( ; i < 5; i++ ) {
-		elems = elems.add("<div style='width:0;height:0;'></div>");
+		elems = elems.add( "<div style='width:0;height:0;'></div>" );
 	}
 
 	foo.append( elems );
@@ -1622,7 +1629,7 @@ test( "hide, fadeOut and slideUp called on element width height and width = 0 sh
 		elems.eq( 2 ).hide( 1 ),
 		elems.eq( 3 ).fadeOut(),
 		elems.eq( 4 ).slideUp()
-	).done(function() {
+	).done( function() {
 		strictEqual( elems.get( 0 ).style.display, "none", "hide() called on element width height and width = 0 should set display to none" );
 		strictEqual( elems.get( 1 ).style.display, "none",
 												"hide( jQuery.noop ) called on element width height and width = 0 should set display to none" );
@@ -1630,28 +1637,28 @@ test( "hide, fadeOut and slideUp called on element width height and width = 0 sh
 		strictEqual( elems.get( 3 ).style.display, "none", "fadeOut() called on element width height and width = 0 should set display to none" );
 		strictEqual( elems.get( 4 ).style.display, "none", "slideUp() called on element width height and width = 0 should set display to none" );
 
-	});
+	} );
 	this.clock.tick( 400 );
-});
+} );
 
 test( "hide should not leave hidden inline elements visible (#14848)", 2, function() {
-	var el = jQuery("#simon1");
+	var el = jQuery( "#simon1" );
 
 	el.hide( 1, function() {
 		equal( el.css( "display" ), "none", "hidden" );
 		el.hide( 1, function() {
 			equal( el.css( "display" ), "none", "still hidden" );
-		});
-	});
+		} );
+	} );
 
 	this.clock.tick( 100 );
-});
+} );
 
 test( "Handle queue:false promises", 10, function() {
 	var foo = jQuery( "#foo" ).clone().addBack(),
 		step = 1;
 
-	foo.animate({
+	foo.animate( {
 		top: 1
 	}, {
 		duration: 10,
@@ -1659,7 +1666,7 @@ test( "Handle queue:false promises", 10, function() {
 		complete: function() {
 			ok( step++ <= 2, "Step one or two" );
 		}
-	}).animate({
+	} ).animate( {
 		bottom: 1
 	}, {
 		duration: 10,
@@ -1667,13 +1674,13 @@ test( "Handle queue:false promises", 10, function() {
 			ok( step > 2 && step < 5, "Step three or four" );
 			step++;
 		}
-	});
+	} );
 
 	this.clock.tick( 10 );
 
 	foo.promise().done( function() {
 		equal( step++, 5, "steps 1-5: queue:false then queue:fx done" );
-		foo.animate({
+		foo.animate( {
 			top: 10
 		}, {
 			duration: 10,
@@ -1681,7 +1688,7 @@ test( "Handle queue:false promises", 10, function() {
 				ok( step > 5 && step < 8, "Step six or seven" );
 				step++;
 			}
-		}).animate({
+		} ).animate( {
 			bottom: 10
 		}, {
 			duration: 10,
@@ -1690,18 +1697,18 @@ test( "Handle queue:false promises", 10, function() {
 				ok( step > 7 && step < 10, "Step eight or nine" );
 				step++;
 			}
-		}).promise().done( function() {
+		} ).promise().done( function() {
 			equal( step++, 10, "steps 6-10: queue:fx then queue:false" );
-		});
+		} );
 
-	});
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 test( "multiple unqueued and promise", 4, function() {
 	var foo = jQuery( "#foo" ),
 		step = 1;
-	foo.animate({
+	foo.animate( {
 		marginLeft: 300
 	}, {
 		duration: 500,
@@ -1709,7 +1716,7 @@ test( "multiple unqueued and promise", 4, function() {
 		complete: function() {
 			strictEqual( step++, 2, "Step 2" );
 		}
-	}).animate({
+	} ).animate( {
 		top: 100
 	}, {
 		duration: 1000,
@@ -1717,50 +1724,51 @@ test( "multiple unqueued and promise", 4, function() {
 		complete: function() {
 			strictEqual( step++, 3, "Step 3" );
 		}
-	}).animate({}, {
+	} ).animate( {}, {
 		duration: 2000,
 		queue: false,
 		complete: function() {
+
 			// no properties is a non-op and finishes immediately
 			strictEqual( step++, 1, "Step 1" );
 		}
-	}).promise().done( function() {
+	} ).promise().done( function() {
 		strictEqual( step++, 4, "Step 4" );
-	});
+	} );
 	this.clock.tick( 1000 );
-});
+} );
 
 test( "animate does not change start value for non-px animation (#7109)", 1, function() {
-	var parent = jQuery( "<div><div></div></div>" ).css({ width: 284, height: 1 }).appendTo( "#qunit-fixture" ),
-		child = parent.children().css({ fontSize: "98.6in", width: "0.01em", height: 1 }),
+	var parent = jQuery( "<div><div></div></div>" ).css( { width: 284, height: 1 } ).appendTo( "#qunit-fixture" ),
+		child = parent.children().css( { fontSize: "98.6in", width: "0.01em", height: 1 } ),
 		actual = parseFloat( child.css( "width" ) ),
 		computed = [];
 
-	child.animate({ width: "0%" }, {
+	child.animate( { width: "0%" }, {
 		duration: 1,
 		step: function() {
 			computed.push( parseFloat( child.css( "width" ) ) );
 		}
-	}).queue( function( next ) {
+	} ).queue( function( next ) {
 		var ratio = computed[ 0 ] / actual;
-		ok( ratio > 0.9 && ratio < 1.1 , "Starting width was close enough" );
+		ok( ratio > 0.9 && ratio < 1.1, "Starting width was close enough" );
 		next();
 		parent.remove();
-	});
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 test( "non-px animation handles non-numeric start (#11971)", 2, function() {
-	var foo = jQuery("#foo"),
-		initial = foo.css("backgroundPositionX");
+	var foo = jQuery( "#foo" ),
+		initial = foo.css( "backgroundPositionX" );
 
 	if ( !initial ) {
-		expect(1);
+		expect( 1 );
 		ok( true, "Style property not understood" );
 		return;
 	}
 
-	foo.animate({ backgroundPositionX: "42%" }, {
+	foo.animate( { backgroundPositionX: "42%" }, {
 		duration: 1,
 		progress: function( anim, percent ) {
 			if ( percent ) {
@@ -1776,9 +1784,9 @@ test( "non-px animation handles non-numeric start (#11971)", 2, function() {
 		done: function() {
 			equal( jQuery.style( this, "backgroundPositionX" ), "42%", "End reached" );
 		}
-	});
+	} );
 	this.clock.tick( 10 );
-});
+} );
 
 QUnit.test( "Animation callbacks (#11797)", function( assert ) {
 	assert.expect( 16 );
@@ -1870,7 +1878,7 @@ QUnit.test( "Animation callbacks (#11797)", function( assert ) {
 test( "Animate properly sets overflow hidden when animating width/height (#12117)", 8, function() {
 	jQuery.each( [ "height", "width" ], function( _, prop ) {
 		jQuery.each( [ 100, 0 ], function( _, value ) {
-			var div = jQuery("<div>").css( "overflow", "auto" ),
+			var div = jQuery( "<div>" ).css( "overflow", "auto" ),
 				props = {};
 			props[ prop ] = value;
 			div.animate( props, 1 );
@@ -1879,24 +1887,24 @@ test( "Animate properly sets overflow hidden when animating width/height (#12117
 			div.stop();
 			equal( div.css( "overflow" ), "auto",
 				"overflow: auto restored after animating " + prop + " to " + value );
-		});
-	});
-});
+		} );
+	} );
+} );
 
 test( "Each tick of the timer loop uses a fresh time (#12837)", function() {
 	var lastVal,
-		tmp = jQuery({
+		tmp = jQuery( {
 			test: 0
-		});
+		} );
 	expect( 3 );
-	tmp.animate({
+	tmp.animate( {
 		test: 100
 	}, {
 		step: function( p, fx ) {
 			ok( fx.now !== lastVal, "Current value is not the last value: " + lastVal + " - " + fx.now );
 			lastVal = fx.now;
 		}
-	});
+	} );
 	this.clock.tick( 1 );
 
 	// now that we have a new time, run another tick
@@ -1906,14 +1914,14 @@ test( "Each tick of the timer loop uses a fresh time (#12837)", function() {
 
 	jQuery.fx.tick();
 	tmp.stop();
-});
+} );
 
 test( "Animations with 0 duration don't ease (#12273)", 1, function() {
 	jQuery.easing.test = function() {
 		ok( false, "Called easing" );
 	};
 
-	jQuery( "#foo" ).animate({
+	jQuery( "#foo" ).animate( {
 		height: 100
 	}, {
 		duration: 0,
@@ -1921,12 +1929,13 @@ test( "Animations with 0 duration don't ease (#12273)", 1, function() {
 		complete: function() {
 			equal( jQuery( this ).height(), 100, "Height is 100" );
 		}
-	});
+	} );
 
 	delete jQuery.easing.test;
-});
+} );
+
+jQuery.map( [ "toggle", "slideToggle", "fadeToggle" ], function( method ) {
 
-jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
 	// this test would look a lot better if we were using something to override
 	// the default timers
 	var duration = 1500;
@@ -1934,7 +1943,7 @@ jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
 		function secondToggle() {
 			var stopped = parseFloat( element.css( check ) );
 			tested = false;
-			element[ method ]({
+			element[ method ]( {
 				duration: duration,
 				step: function( p, fx ) {
 					if ( fx.pos > 0.1 && fx.prop === check && !tested ) {
@@ -1944,17 +1953,17 @@ jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
 						element.stop();
 					}
 				}
-			});
+			} );
 		}
 
 		var tested,
 			original,
 			check = method === "slideToggle" ? "height" : "opacity",
-			element = jQuery("#foo").height( 200 );
+			element = jQuery( "#foo" ).height( 200 );
 
 		expect( 4 );
 
-		element[ method ]({
+		element[ method ]( {
 			duration: duration,
 			easing: "linear",
 			step: function( p, fx ) {
@@ -1967,16 +1976,17 @@ jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
 				}
 			},
 			always: secondToggle
-		});
+		} );
+
                 //FIXME figure out why 470
 		this.clock.tick( 470 );
-	});
-});
+	} );
+} );
 
 test( "jQuery.fx.start & jQuery.fx.stop hook points", function() {
 	var oldStart = jQuery.fx.start,
 		oldStop = jQuery.fx.stop,
-		foo = jQuery({ foo: 0 });
+		foo = jQuery( { foo: 0 } );
 
 	expect( 3 );
 
@@ -1988,17 +1998,19 @@ test( "jQuery.fx.start & jQuery.fx.stop hook points", function() {
 	};
 
 	// calls start
-	foo.animate({ foo: 1 }, { queue: false });
+	foo.animate( { foo: 1 }, { queue: false } );
+
 	// calls start
-	foo.animate({ foo: 2 }, { queue: false });
+	foo.animate( { foo: 2 }, { queue: false } );
 	foo.stop();
+
 	// calls stop
 	jQuery.fx.tick();
 
 	// cleanup
 	jQuery.fx.start = oldStart;
 	jQuery.fx.stop = oldStop;
-});
+} );
 
 test( ".finish() completes all queued animations", function() {
 	var animations = {
@@ -2007,31 +2019,33 @@ test( ".finish() completes all queued animations", function() {
 			height: 100,
 			width: 100
 		},
-		div = jQuery("<div>");
+		div = jQuery( "<div>" );
 
 	expect( 11 );
 
 	jQuery.each( animations, function( prop, value ) {
 		var anim = {};
 		anim[ prop ] = value;
+
 		// the delay shouldn't matter at all!
 		div.css( prop, 1 ).animate( anim, function() {
 			ok( true, "Called animation callback for " + prop );
-		}).delay( 100 );
-	});
+		} ).delay( 100 );
+	} );
 	equal( div.queue().length, 8, "8 animations in the queue" );
 	div.finish();
 	jQuery.each( animations, function( prop, value ) {
 		equal( parseFloat( div.css( prop ) ), value, prop + " finished at correct value" );
-	});
+	} );
 	equal( div.queue().length, 0, "empty queue when done" );
-	equal( div.is(":animated"), false, ":animated doesn't match" );
+	equal( div.is( ":animated" ), false, ":animated doesn't match" );
 
 	// cleanup
 	div.remove();
+
 	// leaves a "shadow timer" which does nothing around, need to force a tick
 	jQuery.fx.tick();
-});
+} );
 
 test( ".finish( false ) - unqueued animations", function() {
 	var animations = {
@@ -2040,7 +2054,7 @@ test( ".finish( false ) - unqueued animations", function() {
 			height: 100,
 			width: 100
 		},
-		div = jQuery("<div>");
+		div = jQuery( "<div>" );
 
 	expect( 10 );
 
@@ -2052,20 +2066,21 @@ test( ".finish( false ) - unqueued animations", function() {
 			complete: function() {
 				ok( true, "Called animation callback for " + prop );
 			}
-		});
-	});
+		} );
+	} );
 	equal( div.queue().length, 0, "0 animations in the queue" );
 	div.finish( false );
 	jQuery.each( animations, function( prop, value ) {
 		equal( parseFloat( div.css( prop ) ), value, prop + " finished at correct value" );
-	});
-	equal( div.is(":animated"), false, ":animated doesn't match" );
+	} );
+	equal( div.is( ":animated" ), false, ":animated doesn't match" );
 
 	// cleanup
 	div.remove();
+
 	// leaves a "shadow timer" which does nothing around, need to force a tick
 	jQuery.fx.tick();
-});
+} );
 
 test( ".finish( \"custom\" ) - custom queue animations", function() {
 	var animations = {
@@ -2074,7 +2089,7 @@ test( ".finish( \"custom\" ) - custom queue animations", function() {
 			height: 100,
 			width: 100
 		},
-		div = jQuery("<div>");
+		div = jQuery( "<div>" );
 
 	expect( 11 );
 
@@ -2086,30 +2101,32 @@ test( ".finish( \"custom\" ) - custom queue animations", function() {
 			complete: function() {
 				ok( true, "Called animation callback for " + prop );
 			}
-		});
-	});
+		} );
+	} );
 	equal( div.queue( "custom" ).length, 4, "4 animations in the queue" );
+
 	// start the first animation
 	div.dequeue( "custom" );
-	equal( div.is(":animated"), true, ":animated matches" );
+	equal( div.is( ":animated" ), true, ":animated matches" );
 	div.finish( "custom" );
 	jQuery.each( animations, function( prop, value ) {
 		equal( parseFloat( div.css( prop ) ), value, prop + " finished at correct value" );
-	});
-	equal( div.is(":animated"), false, ":animated doesn't match" );
+	} );
+	equal( div.is( ":animated" ), false, ":animated doesn't match" );
 
 	// cleanup
 	div.remove();
+
 	// leaves a "shadow timer" which does nothing around, need to force a tick
 	jQuery.fx.tick();
-});
+} );
 
 test( ".finish() calls finish of custom queue functions", function() {
 	function queueTester( next, hooks ) {
 		hooks.stop = function( gotoEnd ) {
 			inside++;
-			equal( this, div[0] );
-			ok( gotoEnd, "hooks.stop(true) called");
+			equal( this, div[ 0 ] );
+			ok( gotoEnd, "hooks.stop(true) called" );
 		};
 	}
 	var div = jQuery( "<div>" ),
@@ -2128,15 +2145,15 @@ test( ".finish() calls finish of custom queue functions", function() {
 	equal( outside, 2, "2 finish callbacks" );
 
 	div.remove();
-});
+} );
 
 test( ".finish() is applied correctly when multiple elements were animated (#13937)", function() {
 	expect( 3 );
 
-	var elems = jQuery("<a>0</a><a>1</a><a>2</a>");
+	var elems = jQuery( "<a>0</a><a>1</a><a>2</a>" );
 
 	elems.animate( { opacity: 0 }, 1500 ).animate( { opacity: 1 }, 1500 );
-	setTimeout(function() {
+	setTimeout( function() {
 		elems.eq( 1 ).finish();
 		ok( !elems.eq( 1 ).queue().length, "empty queue for .finish()ed element" );
 		ok( elems.eq( 0 ).queue().length, "non-empty queue for preceding element" );
@@ -2145,11 +2162,11 @@ test( ".finish() is applied correctly when multiple elements were animated (#139
 
 	}, 100 );
 	this.clock.tick( 1500 );
-});
+} );
 
 test( "slideDown() after stop() (#13483)", 2, function() {
 		var ul = jQuery( "<ul style='height: 100px; display: block;'></ul>" )
-				.appendTo("#qunit-fixture"),
+				.appendTo( "#qunit-fixture" ),
 			origHeight = ul.height(),
 			clock = this.clock;
 
@@ -2173,10 +2190,10 @@ test( "slideDown() after stop() (#13483)", 2, function() {
 				ul.remove();
 				clock.tick( 10 );
 
-		});
+		} );
 
 		clock.tick( 10 );
-});
+} );
 
 test( "Respect display value on inline elements (#14824)", 2, function() {
 	var clock = this.clock,
@@ -2185,21 +2202,21 @@ test( "Respect display value on inline elements (#14824)", 2, function() {
 
 	jQuery( "#qunit-fixture" ).append( fromStyleSheet, fromStyleAttr );
 
-	fromStyleSheet.slideUp(function() {
+	fromStyleSheet.slideUp( function() {
 		jQuery( this ).slideDown( function() {
 			equal( jQuery( this ).css( "display" ), "block",
 				"Respect previous display value (from stylesheet) on span element" );
-		});
-	});
+		} );
+	} );
 
 	fromStyleAttr.slideUp( function() {
 		jQuery( this ).slideDown( function() {
 			equal( jQuery( this ).css( "display" ), "block",
 				"Respect previous display value (from style attribute) on span element" );
-		});
-	});
+		} );
+	} );
 
 	clock.tick( 800 );
-});
+} );
 
-})();
+} )();
diff --git a/test/unit/event.js b/test/unit/event.js
index e8201f93c..ab768439f 100644
--- a/test/unit/event.js
+++ b/test/unit/event.js
@@ -938,9 +938,9 @@ if ( jQuery.fn.click ) {
 		jQuery( "#simon1" ).click();
 		assert.equal( clickCounter, 1, "Check that click, triggers onclick event handler on an a tag also" );
 
-		elem = jQuery("<img />").load(function(){
-			ok( true, "Trigger the load event, using the shortcut .load() (#2819)");
-		}).load();
+		elem = jQuery( "<img />" ).load( function() {
+			ok( true, "Trigger the load event, using the shortcut .load() (#2819)" );
+		} ).load();
 
 		// manually clean up detached elements
 		elem.remove();
@@ -1230,7 +1230,7 @@ QUnit.test( "trigger(eventObject, [data], [fn])", function( assert ) {
 	//$child.on("foo", error );
 
 	event = new jQuery.Event( "foo" );
-	$child.trigger( event, [ 1,2,3 ] ).off();
+	$child.trigger( event, [ 1, 2, 3 ] ).off();
 	assert.equal( event.result, "result", "Check event.result attribute" );
 
 	// Will error if it bubbles
@@ -2727,6 +2727,7 @@ QUnit.test( "Inline event result is returned (#13993)", function( assert ) {
 } );
 
 QUnit.test( ".off() removes the expando when there's no more data", function( assert ) {
+
 	// Support: IE 8 only
 	// IE 8 gets the expando removed via removeAttribute so the second assertion
 	// won't be reached.
diff --git a/test/unit/manipulation.js b/test/unit/manipulation.js
index fb9c454fb..76b40997c 100644
--- a/test/unit/manipulation.js
+++ b/test/unit/manipulation.js
@@ -2348,25 +2348,24 @@ QUnit.test( "Ensure oldIE creates a new set on appendTo (#8894)", function( asse
 	assert.strictEqual( jQuery( "<p/>" ).appendTo( "<div/>" ).end().length, jQuery( "<p>test</p>" ).appendTo( "<div/>" ).end().length, "Elements created with createElement and with createDocumentFragment should be treated alike" );
 } );
 
-
 test( "html() - script exceptions bubble (#11743)", function() {
 
 	expect( 2 );
 
-	throws(function() {
-		jQuery("#qunit-fixture").html("<script>undefined(); ok( false, 'Exception not thrown' );</script>");
+	throws( function() {
+		jQuery( "#qunit-fixture" ).html( "<script>undefined(); ok( false, 'Exception not thrown' );</script>" );
 		ok( false, "Exception ignored" );
 	}, "Exception bubbled from inline script" );
 
 	if ( jQuery.ajax ) {
-		throws(function() {
-			jQuery("#qunit-fixture").html("<script src='data/badcall.js'></script>");
+		throws( function() {
+			jQuery( "#qunit-fixture" ).html( "<script src='data/badcall.js'></script>" );
 			ok( false, "Exception ignored" );
 		}, "Exception thrown in remote script" );
 	} else {
 		ok( true, "No jQuery.ajax" );
 	}
-});
+} );
 
 QUnit.test( "checked state is cloned with clone()", function( assert ) {
 
diff --git a/test/unit/offset.js b/test/unit/offset.js
index 768284f26..7a8624a92 100644
--- a/test/unit/offset.js
+++ b/test/unit/offset.js
@@ -43,20 +43,20 @@ QUnit.module( "offset", { setup: function() {
 	the iframe window and the "jQuery" symbol is used to access any static methods.
 */
 
-test("empty set", function() {
-	expect(2);
+test( "empty set", function() {
+	expect( 2 );
 	strictEqual( jQuery().offset(), undefined, "offset() returns undefined for empty set (#11962)" );
 	strictEqual( jQuery().position(), undefined, "position() returns undefined for empty set (#11962)" );
-});
+} );
 
-test("object without getBoundingClientRect", function() {
-	expect(2);
+test( "object without getBoundingClientRect", function() {
+	expect( 2 );
 
 	// Simulates a browser without gBCR on elements, we just want to return 0,0
-	var result = jQuery({ ownerDocument: document }).offset();
+	var result = jQuery( { ownerDocument: document } ).offset();
 	equal( result.top, 0, "Check top" );
 	equal( result.left, 0, "Check left" );
-});
+} );
 
 QUnit.test( "disconnected element", function( assert ) {
 	assert.expect( 2 );
@@ -497,10 +497,10 @@ testIframe( "offset/body", "body", function( $, window, document, assert ) {
 QUnit.test( "chaining", function( assert ) {
 	assert.expect( 3 );
 	var coords = { "top":  1, "left":  1 };
-	equal( jQuery("#absolute-1").offset(coords).selector, "#absolute-1", "offset(coords) returns jQuery object" );
-	equal( jQuery("#non-existent").offset(coords).selector, "#non-existent", "offset(coords) with empty jQuery set returns jQuery object" );
-	equal( jQuery("#absolute-1").offset(undefined).selector, "#absolute-1", "offset(undefined) returns jQuery object (#5571)" );
-});
+	equal( jQuery( "#absolute-1" ).offset( coords ).selector, "#absolute-1", "offset(coords) returns jQuery object" );
+	equal( jQuery( "#non-existent" ).offset( coords ).selector, "#non-existent", "offset(coords) with empty jQuery set returns jQuery object" );
+	equal( jQuery( "#absolute-1" ).offset( undefined ).selector, "#absolute-1", "offset(undefined) returns jQuery object (#5571)" );
+} );
 
 QUnit.test( "offsetParent", function( assert ) {
 	assert.expect( 13 );
diff --git a/test/unit/ready.js b/test/unit/ready.js
index 70deff5d2..611b26286 100644
--- a/test/unit/ready.js
+++ b/test/unit/ready.js
@@ -1,6 +1,6 @@
 QUnit.module( "ready" );
 
-(function(){
+( function() {
 	var notYetReady, noEarlyExecution,
 		order = [],
 		args = {};
@@ -16,6 +16,7 @@ QUnit.module( "ready" );
 
 	// Create an event handler.
 	function makeHandler( testId ) {
+
 		// When returned function is executed, push testId onto `order` array
 		// to ensure execution order. Also, store event handler arg to ensure
 		// the correct arg is being passed into the event handler.
@@ -26,48 +27,48 @@ QUnit.module( "ready" );
 	}
 
 	// Bind to the ready event in every possible way.
-	jQuery(makeHandler("a"));
-	jQuery(document).ready(makeHandler("b"));
-	jQuery(document).on("ready.readytest", makeHandler("c"));
+	jQuery( makeHandler( "a" ) );
+	jQuery( document ).ready( makeHandler( "b" ) );
+	jQuery( document ).on( "ready.readytest", makeHandler( "c" ) );
 
 	// Do it twice, just to be sure.
-	jQuery(makeHandler("d"));
-	jQuery(document).ready(makeHandler("e"));
-	jQuery(document).on("ready.readytest", makeHandler("f"));
+	jQuery( makeHandler( "d" ) );
+	jQuery( document ).ready( makeHandler( "e" ) );
+	jQuery( document ).on( "ready.readytest", makeHandler( "f" ) );
 
 	noEarlyExecution = order.length === 0;
 
 	// This assumes that QUnit tests are run on DOM ready!
-	QUnit.test("jQuery ready", function() {
-		expect(10);
+	QUnit.test( "jQuery ready", function() {
+		expect( 10 );
 
-		ok(noEarlyExecution, "Handlers bound to DOM ready should not execute before DOM ready");
+		ok( noEarlyExecution, "Handlers bound to DOM ready should not execute before DOM ready" );
 
 		// Ensure execution order.
-		deepEqual(order, ["a", "b", "d", "e", "c", "f"], "Bound DOM ready handlers should execute in on-order, but those bound with jQuery(document).on( 'ready', fn ) will always execute last");
+		deepEqual( order, [ "a", "b", "d", "e", "c", "f" ], "Bound DOM ready handlers should execute in on-order, but those bound with jQuery(document).on( 'ready', fn ) will always execute last" );
 
 		// Ensure handler argument is correct.
-		equal(args["a"], jQuery, "Argument passed to fn in jQuery( fn ) should be jQuery");
-		equal(args["b"], jQuery, "Argument passed to fn in jQuery(document).ready( fn ) should be jQuery");
-		ok(args["c"] instanceof jQuery.Event, "Argument passed to fn in jQuery(document).on( 'ready', fn ) should be an event object");
+		equal( args[ "a" ], jQuery, "Argument passed to fn in jQuery( fn ) should be jQuery" );
+		equal( args[ "b" ], jQuery, "Argument passed to fn in jQuery(document).ready( fn ) should be jQuery" );
+		ok( args[ "c" ] instanceof jQuery.Event, "Argument passed to fn in jQuery(document).on( 'ready', fn ) should be an event object" );
 
 		order = [];
 
 		// Now that the ready event has fired, again bind to the ready event
 		// in every possible way. These event handlers should execute immediately.
-		jQuery(makeHandler("g"));
-		equal(order.pop(), "g", "Event handler should execute immediately");
-		equal(args["g"], jQuery, "Argument passed to fn in jQuery( fn ) should be jQuery");
+		jQuery( makeHandler( "g" ) );
+		equal( order.pop(), "g", "Event handler should execute immediately" );
+		equal( args[ "g" ], jQuery, "Argument passed to fn in jQuery( fn ) should be jQuery" );
 
-		jQuery(document).ready(makeHandler("h"));
-		equal(order.pop(), "h", "Event handler should execute immediately");
-		equal(args["h"], jQuery, "Argument passed to fn in jQuery(document).ready( fn ) should be jQuery");
+		jQuery( document ).ready( makeHandler( "h" ) );
+		equal( order.pop(), "h", "Event handler should execute immediately" );
+		equal( args[ "h" ], jQuery, "Argument passed to fn in jQuery(document).ready( fn ) should be jQuery" );
 
-		jQuery(document).on("ready.readytest", makeHandler("never"));
-		equal(order.length, 0, "Event handler should never execute since DOM ready has already passed");
+		jQuery( document ).on( "ready.readytest", makeHandler( "never" ) );
+		equal( order.length, 0, "Event handler should never execute since DOM ready has already passed" );
 
 		// Cleanup.
-		jQuery(document).off("ready.readytest");
-	});
+		jQuery( document ).off( "ready.readytest" );
+	} );
 
 } )();
diff --git a/test/unit/selector.js b/test/unit/selector.js
index 969b7abaf..ed0d508ca 100644
--- a/test/unit/selector.js
+++ b/test/unit/selector.js
@@ -32,7 +32,7 @@ QUnit.test( "id", function( assert ) {
 	assert.t( "ID selector with existing ID descendant", "#firstp #simon1", [ "simon1" ] );
 	assert.t( "ID selector with non-existant descendant", "#firstp #foobar", [] );
 	assert.t( "ID selector using UTF8", "#台北Táiběi", [ "台北Táiběi" ] );
-	assert.t( "Multiple ID selectors using UTF8", "#台北Táiběi, #台北", [ "台北Táiběi","台北" ] );
+	assert.t( "Multiple ID selectors using UTF8", "#台北Táiběi, #台北", [ "台北Táiběi", "台北" ] );
 	assert.t( "Descendant ID selector using UTF8", "div #台北", [ "台北" ] );
 	assert.t( "Child ID selector using UTF8", "form > #台北", [ "台北" ] );
 
@@ -105,14 +105,14 @@ QUnit.test( "child and adjacent", function( assert ) {
 
 	var nothiddendiv;
 
-	assert.t( "Child", "p > a", [ "simon1","google","groups","mark","yahoo","simon" ] );
-	assert.t( "Child", "p> a", [ "simon1","google","groups","mark","yahoo","simon" ] );
-	assert.t( "Child", "p >a", [ "simon1","google","groups","mark","yahoo","simon" ] );
-	assert.t( "Child", "p>a", [ "simon1","google","groups","mark","yahoo","simon" ] );
-	assert.t( "Child w/ Class", "p > a.blog", [ "mark","simon" ] );
-	assert.t( "All Children", "code > *", [ "anchor1","anchor2" ] );
-	assert.t( "All Grandchildren", "p > * > *", [ "anchor1","anchor2" ] );
-	assert.t( "Adjacent", "p + p", [ "ap","en","sap" ] );
+	assert.t( "Child", "p > a", [ "simon1", "google", "groups", "mark", "yahoo", "simon" ] );
+	assert.t( "Child", "p> a", [ "simon1", "google", "groups", "mark", "yahoo", "simon" ] );
+	assert.t( "Child", "p >a", [ "simon1", "google", "groups", "mark", "yahoo", "simon" ] );
+	assert.t( "Child", "p>a", [ "simon1", "google", "groups", "mark", "yahoo", "simon" ] );
+	assert.t( "Child w/ Class", "p > a.blog", [ "mark", "simon" ] );
+	assert.t( "All Children", "code > *", [ "anchor1", "anchor2" ] );
+	assert.t( "All Grandchildren", "p > * > *", [ "anchor1", "anchor2" ] );
+	assert.t( "Adjacent", "p + p", [ "ap", "en", "sap" ] );
 	assert.t( "Adjacent", "p#firstp + p", [ "ap" ] );
 	assert.t( "Adjacent", "p[lang=en] + p", [ "sap" ] );
 	assert.t( "Adjacent", "a.GROUPS + code + a", [ "mark" ] );
@@ -162,7 +162,7 @@ QUnit.test( "attributes", function( assert ) {
 	assert.t( "Attribute Equals", "#qunit-fixture a[rel=bookmark]", [ "simon1" ] );
 	assert.t( "Attribute Equals", "#qunit-fixture a[href='http://www.google.com/']", [ "google" ] );
 	assert.t( "Attribute Equals", "#qunit-fixture a[ rel = 'bookmark' ]", [ "simon1" ] );
-	assert.t( "Attribute Equals Number", "#qunit-fixture option[value=1]", [ "option1b","option2b","option3b","option4b","option5c" ] );
+	assert.t( "Attribute Equals Number", "#qunit-fixture option[value=1]", [ "option1b", "option2b", "option3b", "option4b", "option5c" ] );
 	assert.t( "Attribute Equals Number", "#qunit-fixture li[tabIndex=-1]", [ "foodWithNegativeTabIndex" ] );
 
 	document.getElementById( "anchor2" ).href = "#2";
@@ -186,13 +186,13 @@ QUnit.test( "attributes", function( assert ) {
 
 	assert.t( "Attribute selector using UTF8", "span[lang=中文]", [ "台北" ] );
 
-	assert.t( "Attribute Begins With", "a[href ^= 'http://www']", [ "google","yahoo" ] );
+	assert.t( "Attribute Begins With", "a[href ^= 'http://www']", [ "google", "yahoo" ] );
 	assert.t( "Attribute Ends With", "a[href $= 'org/']", [ "mark" ] );
-	assert.t( "Attribute Contains", "a[href *= 'google']", [ "google","groups" ] );
-	assert.t( "Attribute Is Not Equal", "#ap a[hreflang!='en']", [ "google","groups","anchor1" ] );
+	assert.t( "Attribute Contains", "a[href *= 'google']", [ "google", "groups" ] );
+	assert.t( "Attribute Is Not Equal", "#ap a[hreflang!='en']", [ "google", "groups", "anchor1" ] );
 
 	assert.t( "Empty values", "#select1 option[value='']", [ "option1a" ] );
-	assert.t( "Empty values", "#select1 option[value!='']", [ "option1b","option1c","option1d" ] );
+	assert.t( "Empty values", "#select1 option[value!='']", [ "option1b", "option1c", "option1d" ] );
 
 	assert.t( "Select options via :selected", "#select1 option:selected", [ "option1a" ] );
 	assert.t( "Select options via :selected", "#select2 option:selected", [ "option2d" ] );
diff --git a/test/unit/serialize.js b/test/unit/serialize.js
index a64593603..72b4a164c 100644
--- a/test/unit/serialize.js
+++ b/test/unit/serialize.js
@@ -10,7 +10,7 @@ QUnit.test( "jQuery.param()", function( assert ) {
 	params = { "foo":"bar", "baz":42, "quux":"All your base are belong to us" };
 	assert.equal( jQuery.param( params ), "foo=bar&baz=42&quux=All+your+base+are+belong+to+us", "simple" );
 
-	params = { "string":"foo","null":null,"undefined":undefined };
+	params = { "string":"foo", "null":null, "undefined":undefined };
 	assert.equal( jQuery.param( params ), "string=foo&null=&undefined=", "handle nulls and undefineds properly" );
 
 	params = { "someName": [ 1, 2, 3 ], "regularThing": "blah" };
@@ -25,16 +25,16 @@ QUnit.test( "jQuery.param()", function( assert ) {
 	params = { "foo": { "bar": "baz", "beep": 42, "quux": "All your base are belong to us" } };
 	assert.equal( jQuery.param( params ), "foo%5Bbar%5D=baz&foo%5Bbeep%5D=42&foo%5Bquux%5D=All+your+base+are+belong+to+us", "even more arrays" );
 
-	params = { a:[ 1,2 ], b:{ c:3, d:[ 4,5 ], e:{ x:[ 6 ], y:7, z:[ 8,9 ] }, f:true, g:false, h:undefined }, i:[ 10,11 ], j:true, k:false, l:[ undefined,0 ], m:"cowboy hat?" };
+	params = { a:[ 1, 2 ], b:{ c:3, d:[ 4, 5 ], e:{ x:[ 6 ], y:7, z:[ 8, 9 ] }, f:true, g:false, h:undefined }, i:[ 10, 11 ], j:true, k:false, l:[ undefined, 0 ], m:"cowboy hat?" };
 	assert.equal( decodeURIComponent( jQuery.param( params ) ), "a[]=1&a[]=2&b[c]=3&b[d][]=4&b[d][]=5&b[e][x][]=6&b[e][y]=7&b[e][z][]=8&b[e][z][]=9&b[f]=true&b[g]=false&b[h]=&i[]=10&i[]=11&j=true&k=false&l[]=&l[]=0&m=cowboy+hat?", "huge structure" );
 
 	params = { "a": [ 0, [ 1, 2 ], [ 3, [ 4, 5 ], [ 6 ] ], { "b": [ 7, [ 8, 9 ], [ { "c": 10, "d": 11 } ], [ [ 12 ] ], [ [ [ 13 ] ] ], { "e": { "f": { "g": [ 14, [ 15 ] ] } } }, 16 ] }, 17 ] };
 	assert.equal( decodeURIComponent( jQuery.param( params ) ), "a[]=0&a[1][]=1&a[1][]=2&a[2][]=3&a[2][1][]=4&a[2][1][]=5&a[2][2][]=6&a[3][b][]=7&a[3][b][1][]=8&a[3][b][1][]=9&a[3][b][2][0][c]=10&a[3][b][2][0][d]=11&a[3][b][3][0][]=12&a[3][b][4][0][0][]=13&a[3][b][5][e][f][g][]=14&a[3][b][5][e][f][g][1][]=15&a[3][b][]=16&a[]=17", "nested arrays" );
 
-	params = { "a":[ 1,2 ], "b":{ "c":3, "d":[ 4,5 ], "e":{ "x":[ 6 ], "y":7, "z":[ 8,9 ] }, "f":true, "g":false, "h":undefined }, "i":[ 10,11 ], "j":true, "k":false, "l":[ undefined,0 ], "m":"cowboy hat?" };
+	params = { "a":[ 1, 2 ], "b":{ "c":3, "d":[ 4, 5 ], "e":{ "x":[ 6 ], "y":7, "z":[ 8, 9 ] }, "f":true, "g":false, "h":undefined }, "i":[ 10, 11 ], "j":true, "k":false, "l":[ undefined, 0 ], "m":"cowboy hat?" };
 	assert.equal( jQuery.param( params, true ), "a=1&a=2&b=%5Bobject+Object%5D&i=10&i=11&j=true&k=false&l=&l=0&m=cowboy+hat%3F", "huge structure, forced traditional" );
 
-	assert.equal( decodeURIComponent( jQuery.param( { "a": [ 1,2,3 ], "b[]": [ 4,5,6 ], "c[d]": [ 7,8,9 ], "e": { "f": [ 10 ], "g": [ 11,12 ], "h": 13 } } ) ), "a[]=1&a[]=2&a[]=3&b[]=4&b[]=5&b[]=6&c[d][]=7&c[d][]=8&c[d][]=9&e[f][]=10&e[g][]=11&e[g][]=12&e[h]=13", "Make sure params are not double-encoded." );
+	assert.equal( decodeURIComponent( jQuery.param( { "a": [ 1, 2, 3 ], "b[]": [ 4, 5, 6 ], "c[d]": [ 7, 8, 9 ], "e": { "f": [ 10 ], "g": [ 11, 12 ], "h": 13 } } ) ), "a[]=1&a[]=2&a[]=3&b[]=4&b[]=5&b[]=6&c[d][]=7&c[d][]=8&c[d][]=9&e[f][]=10&e[g][]=11&e[g][]=12&e[h]=13", "Make sure params are not double-encoded." );
 
 	// #7945
 	assert.equal( jQuery.param( { "jquery": "1.4.2" } ), "jquery=1.4.2", "Check that object with a jQuery property get serialized correctly" );
@@ -62,13 +62,13 @@ QUnit.test( "jQuery.param()", function( assert ) {
 	params = { "foo[bar]":"baz", "foo[beep]":42, "foo[quux]":"All your base are belong to us" };
 	assert.equal( jQuery.param( params ), "foo%5Bbar%5D=baz&foo%5Bbeep%5D=42&foo%5Bquux%5D=All+your+base+are+belong+to+us", "even more arrays" );
 
-	params = { a:[ 1,2 ], b:{ c:3, d:[ 4,5 ], e:{ x:[ 6 ], y:7, z:[ 8,9 ] }, f:true, g:false, h:undefined }, i:[ 10,11 ], j:true, k:false, l:[ undefined,0 ], m:"cowboy hat?" };
+	params = { a:[ 1, 2 ], b:{ c:3, d:[ 4, 5 ], e:{ x:[ 6 ], y:7, z:[ 8, 9 ] }, f:true, g:false, h:undefined }, i:[ 10, 11 ], j:true, k:false, l:[ undefined, 0 ], m:"cowboy hat?" };
 	assert.equal( jQuery.param( params ), "a=1&a=2&b=%5Bobject+Object%5D&i=10&i=11&j=true&k=false&l=&l=0&m=cowboy+hat%3F", "huge structure" );
 
 	params = { "a": [ 0, [ 1, 2 ], [ 3, [ 4, 5 ], [ 6 ] ], { "b": [ 7, [ 8, 9 ], [ { "c": 10, d: 11 } ], [ [ 12 ] ], [ [ [ 13 ] ] ], { "e": { "f": { "g": [ 14, [ 15 ] ] } } }, 16 ] }, 17 ] };
 	assert.equal( jQuery.param( params ), "a=0&a=1%2C2&a=3%2C4%2C5%2C6&a=%5Bobject+Object%5D&a=17", "nested arrays (not possible when jQuery.param.traditional == true)" );
 
-	params = { a:[ 1,2 ], b:{ c:3, d:[ 4,5 ], e:{ x:[ 6 ], y:7, z:[ 8,9 ] }, f:true, g:false, h:undefined }, i:[ 10,11 ], j:true, k:false, l:[ undefined,0 ], m:"cowboy hat?" };
+	params = { a:[ 1, 2 ], b:{ c:3, d:[ 4, 5 ], e:{ x:[ 6 ], y:7, z:[ 8, 9 ] }, f:true, g:false, h:undefined }, i:[ 10, 11 ], j:true, k:false, l:[ undefined, 0 ], m:"cowboy hat?" };
 	assert.equal( decodeURIComponent( jQuery.param( params, false ) ), "a[]=1&a[]=2&b[c]=3&b[d][]=4&b[d][]=5&b[e][x][]=6&b[e][y]=7&b[e][z][]=8&b[e][z][]=9&b[f]=true&b[g]=false&b[h]=&i[]=10&i[]=11&j=true&k=false&l[]=&l[]=0&m=cowboy+hat?", "huge structure, forced not traditional" );
 
 	params = { "param1": null };
diff --git a/test/unit/support.js b/test/unit/support.js
index 7644ced86..df2e7e595 100644
--- a/test/unit/support.js
+++ b/test/unit/support.js
@@ -535,6 +535,6 @@ testIframeWithCallback(
 				assert.ok( true, "no ajax; skipping jQuery.support['" + i + "']" );
 			}
 		}
-	});
+	} );
 
 } )();
-- 
2.39.5