diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..b5bd7f60
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,16 @@
+# This file is for unifying the coding style for different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+indent_style = tab
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[package.json]
+indent_style = space
+indent_size = 2
+
diff --git a/.jscsrc b/.jscsrc
new file mode 100644
index 00000000..85ed8857
--- /dev/null
+++ b/.jscsrc
@@ -0,0 +1,5 @@
+"preset": "jquery"
+"requireCamelCaseOrUpperCaseIdentifiers": {
+	"ignoreProperties": true
+}
+"excludeFiles": [ "external", "src/intro.js", "src/outro.js", "node_modules" ]
diff --git a/.travis.yml b/.travis.yml
index e34e2f36..df2b62dd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,4 +2,4 @@ language: node_js
 sudo: false
 node_js:
 - "5"
-before_install: npm install -g grunt-cli
+script: "npm run ci"
diff --git a/Gruntfile.js b/Gruntfile.js
index e4264b2a..1c7b31e4 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -1,5 +1,5 @@
 /*global module:false*/
-module.exports = function(grunt) {
+module.exports = function( grunt ) {
 
 	"use strict";
 
@@ -8,15 +8,15 @@ module.exports = function(grunt) {
 			var data = {};
 			try {
 				data = grunt.file.readJSON( filepath );
-			} catch(e) {}
+			} catch ( e ) {}
 			return data;
 		},
-		srcHintOptions = readOptionalJSON("src/.jshintrc");
+		srcHintOptions = readOptionalJSON( "src/.jshintrc" );
 	delete srcHintOptions.onevar;
 
 	// Project configuration.
-	grunt.initConfig({
-		pkg: grunt.file.readJSON("package.json"),
+	grunt.initConfig( {
+		pkg: grunt.file.readJSON( "package.json" ),
 		files: [
 			"src/intro.js",
 			"src/version.js",
@@ -63,11 +63,28 @@ module.exports = function(grunt) {
 					instrumentedFiles: "temp/",
 					src: [ "dist/jquery-migrate.js" ],
 					htmlReport: "coverage/",
+					lcovReport: "coverage/",
 					linesThresholdPct: 85
 				}
 			},
 			files: [ "test/**/*.html" ]
 		},
+		coveralls: {
+			src: "coverage/lcov.info",
+			options: {
+
+				// Should not fail if coveralls is down
+				force: true
+			}
+		},
+		jscs: {
+			src: [
+				"test/**/*.js",
+				"<%= files %>",
+				"Gruntfile.js",
+				"build/**/*.js"
+			]
+		},
 		npmcopy: {
 			all: {
 				options: {
@@ -77,7 +94,7 @@ module.exports = function(grunt) {
 					"phantomjs-polyfill/bind-polyfill.js": "phantomjs-polyfill/bind-polyfill.js",
 					"qunit/qunit.js": "qunitjs/qunit/qunit.js",
 					"qunit/qunit.css": "qunitjs/qunit/qunit.css",
-					"qunit/LICENSE.txt": "qunitjs/LICENSE.txt"				}
+					"qunit/LICENSE.txt": "qunitjs/LICENSE.txt" }
 			}
 		},
 		jshint: {
@@ -105,7 +122,8 @@ module.exports = function(grunt) {
 				}
 			},
 			options: {
-				banner: "/*! jQuery Migrate v<%= pkg.version %> | (c) <%= pkg.author.name %> | jquery.org/license */\n",
+				banner: "/*! jQuery Migrate v<%= pkg.version %>" +
+					" | (c) <%= pkg.author.name %> | jquery.org/license */\n",
 				beautify: {
 					ascii_only: true
 				}
@@ -113,77 +131,32 @@ module.exports = function(grunt) {
 		},
 		watch: {
 			files: [ "src/*.js", "test/*.js" ],
-			tasks: [ "buildnounit" ]
-		},
-	});
+			tasks: [ "build" ]
+		}
+	} );
 
 	// Load grunt tasks from NPM packages
-	grunt.loadNpmTasks("grunt-git-authors");
-	grunt.loadNpmTasks("grunt-contrib-concat");
-	grunt.loadNpmTasks("grunt-contrib-watch");
-	grunt.loadNpmTasks("grunt-contrib-jshint");
-	grunt.loadNpmTasks("grunt-contrib-uglify");
-	grunt.loadNpmTasks("grunt-qunit-istanbul");
-	grunt.loadNpmTasks("grunt-npmcopy");
-
-	// Default task.
-	grunt.registerTask( "default", [ "concat", "uglify", "jshint", "qunit" ] );
+	grunt.loadNpmTasks( "grunt-git-authors" );
+	grunt.loadNpmTasks( "grunt-contrib-concat" );
+	grunt.loadNpmTasks( "grunt-contrib-watch" );
+	grunt.loadNpmTasks( "grunt-contrib-jshint" );
+	grunt.loadNpmTasks( "grunt-jscs" );
+	grunt.loadNpmTasks( "grunt-contrib-uglify" );
+	grunt.loadNpmTasks( "grunt-qunit-istanbul" );
+	grunt.loadNpmTasks( "grunt-coveralls" );
+	grunt.loadNpmTasks( "grunt-npmcopy" );
 
-	// Skip unit tests, used by testswarm
-	grunt.registerTask( "buildnounit", [ "concat", "uglify", "jshint" ] );
+	// Integrate jQuery migrate specific tasks
+	grunt.loadTasks( "build/tasks" );
 
-	// Testswarm
-	grunt.registerTask( "testswarm", function( commit, configFile, destName ) {
-		var jobName,
-			testswarm = require( "testswarm" ),
-			runs = {},
-			done = this.async(),
-			pull = /PR-(\d+)/.exec( commit ),
-			config = grunt.file.readJSON( configFile ).jquerymigrate,
-			tests = grunt.config( "tests" )[ destName ],
-			browserSets = destName || config.browserSets;
+	// Just an alias
+	grunt.registerTask( "test", [ "qunit" ] );
 
-		if ( browserSets[ 0 ] === "[" ) {
-			// We got an array, parse it
-			browserSets = JSON.parse( browserSets );
-		}
+	grunt.registerTask( "lint", [ "jshint", "jscs" ] );
+	grunt.registerTask( "build", [ "concat", "uglify", "lint" ] );
 
-		if ( pull ) {
-			jobName = "Pull <a href='https://github.com/jquery/jquery-migrate/pull/" +
-				pull[ 1 ] + "'>#" + pull[ 1 ] + "</a>";
-		} else {
-			jobName = "Commit <a href='https://github.com/jquery/jquery-migrate/commit/" +
-				commit + "'>" + commit.substr( 0, 10 ) + "</a>";
-		}
+	grunt.registerTask( "default", [ "build", "test" ] );
 
-		tests.forEach(function( test ) {
-			var plugin_jquery = test.split("+");
-			runs[test] = config.testUrl + commit + "/test/index.html?plugin=" +
-				plugin_jquery[0] + "&jquery=" + plugin_jquery[1];
-		});
-
-		// TODO: create separate job for git so we can do different browsersets
-		testswarm.createClient( {
-			url: config.swarmUrl
-		} )
-		.addReporter( testswarm.reporters.cli )
-		.auth( {
-			id: config.authUsername,
-			token: config.authToken
-		})
-		.addjob(
-			{
-				name: jobName,
-				runs: runs,
-				runMax: config.runMax,
-				browserSets: browserSets,
-				timeout: 1000 * 60 * 30
-			}, function( err, passed ) {
-				if ( err ) {
-					grunt.log.error( err );
-				}
-				done( passed );
-			}
-		);
-	});
+	// For CI
+	grunt.registerTask( "ci", [ "build", "test", "coveralls" ] );
 };
diff --git a/README.md b/README.md
index ea1a7ef6..92d6b8d1 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,7 @@
-# jquery-migrate: Migrate older jQuery code to jQuery 1.9+
+[![Build Status](https://travis-ci.org/jquery/jquery-migrate.svg?branch=master)](https://travis-ci.org/jquery/jquery-migrate)
+[![Coverage Status](https://img.shields.io/coveralls/jquery/jquery-migrate.svg?style=flat)](https://coveralls.io/r/jquery/jquery-migrate?branch=master)
+
+# Migrate older jQuery code to jQuery 1.9+
 
 This plugin can be used to detect and restore APIs or features that have been deprecated in jQuery and removed as of version 1.9.
 See the [warnings page](https://github.com/jquery/jquery-migrate/blob/master/warnings.md) for more information regarding messages the plugin generates.
@@ -65,19 +68,35 @@ Bugs in jQuery itself should be reported on the [jQuery Core bug tracker](http:/
 
 For other questions about the plugin that aren't bugs, ask on the [jQuery Forum](http://forum.jquery.com).
 
-How to run the tests:
+Build and run tests:
 ====================================================
-Clone this repo, install `grunt`:
+
+## Build with `npm` commands
+```sh
+$ git clone git://github.com/jquery/jquery-migrate.git
+$ cd jquery-migrate
+$ npm install
+$ npm run build
+```
+
+## Build with [`grunt`](http://gruntjs.com/)
+
+```sh
+$ git clone git://github.com/jquery/jquery-migrate.git
+$ cd jquery-migrate
+$ npm install
+$ npm install -g grunt-cli
+$ grunt build
+```
+
+### Run tests
 
 ```sh
-git clone git://github.com/jquery/jquery-migrate.git
-cd jquery-migrate
-npm install
-npm install -g grunt-cli
+$ npm test
 ```
 
-Run `grunt` to `jshint`, `qunit` and `uglify` release.
+### Or
 
 ```sh
-grunt
+$ grunt test
 ```
diff --git a/build/release.js b/build/release.js
index 567b6871..f8fbfcb4 100644
--- a/build/release.js
+++ b/build/release.js
@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /*
- * jQuery Migrate Plugin Release Management
+ * JQuery Migrate Plugin Release Management
  */
 
 // Debugging variables
@@ -46,7 +46,8 @@ steps(
 	tagReleaseVersion,
 	gruntBuild,
 	makeReleaseCopies,
-	// uploadToCDN,
+
+	// UploadToCDN,
 	publishToNPM,
 	setNextVersion,
 	pushToRemote,
@@ -56,19 +57,19 @@ steps(
 function initialize( next ) {
 
 	// -d dryrun mode, no commands are executed at all
-	if ( process.argv[2] === "-d" ) {
+	if ( process.argv[ 2 ] === "-d" ) {
 		process.argv.shift();
 		dryrun = true;
-		console.warn("=== DRY RUN MODE ===" );
+		console.warn( "=== DRY RUN MODE ===" );
 	}
 
 	// -r skip remote mode, no remote commands are executed
 	// (git push, npm publish, cdn copy)
 	// Reset with `git reset --hard HEAD~2 && git tag -d (version) && grunt`
-	if ( process.argv[2] === "-r" ) {
+	if ( process.argv[ 2 ] === "-r" ) {
 		process.argv.shift();
 		skipRemote = true;
-		console.warn("=== SKIPREMOTE MODE ===" );
+		console.warn( "=== SKIPREMOTE MODE ===" );
 	}
 
 	// First arg should be the version number being released; this is a proper subset
@@ -76,14 +77,13 @@ function initialize( next ) {
 	// Examples: 1.0.1, 1.0.1-pre, 1.0.1-rc1, 1.0.1-rc1.1
 	var newver, oldver,
 		rsemver = /^(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z\-]+(?:\.[\dA-Za-z\-]+)*))?$/,
-		version = rsemver.exec( process.argv[2] || "" ) || [],
-		major = version[1],
-		minor = version[2],
-		patch = version[3],
-		xbeta = version[4];
-
+		version = rsemver.exec( process.argv[ 2 ] || "" ) || [],
+		major = version[ 1 ],
+		minor = version[ 2 ],
+		patch = version[ 3 ],
+		xbeta = version[ 4 ];
 
-	releaseVersion = process.argv[2];
+	releaseVersion = process.argv[ 2 ];
 	isBeta = !!xbeta;
 
 	if ( !releaseVersion ) {
@@ -95,14 +95,14 @@ function initialize( next ) {
 	if ( xbeta === "pre" ) {
 		die( "Cannot release a 'pre' version!" );
 	}
-	if ( !(fs.existsSync || path.existsSync)( packageFile ) ) {
+	if ( !( fs.existsSync || path.existsSync )( packageFile ) ) {
 		die( "No " + packageFile + " in this directory" );
 	}
 	pkg = JSON.parse( fs.readFileSync( packageFile ) );
 
 	status( "Current version is " + pkg.version + "; generating release " + releaseVersion );
 	version = rsemver.exec( pkg.version );
-	oldver = ( +version[1] ) * 10000 + ( +version[2] * 100 ) + ( +version[3] )
+	oldver = ( +version[ 1 ] ) * 10000 + ( +version[ 2 ] * 100 ) + ( +version[ 3 ] );
 	newver = ( +major ) * 10000 + ( +minor * 100 ) + ( +patch );
 	if ( newver < oldver ) {
 		die( "Next version is older than current version!" );
@@ -119,24 +119,24 @@ function initialize( next ) {
 
 function checkGitStatus( next ) {
 	child.execFile( "git", [ "status" ], function( error, stdout, stderr ) {
-		var onBranch = ((stdout||"").match( /On branch (\S+)/ ) || [])[1];
+		var onBranch = ( ( stdout || "" ).match( /On branch (\S+)/ ) || [] )[ 1 ];
 		if ( onBranch !== branch ) {
 			die( "Branches don't match: Wanted " + branch + ", got " + onBranch );
 		}
 		if ( /Changes to be committed/i.test( stdout ) ) {
-			die("Please commit changed files before attemping to push a release.");
+			die( "Please commit changed files before attemping to push a release." );
 		}
 		if ( /Changes not staged for commit/i.test( stdout ) ) {
-			die("Please stash files before attempting to push a release.");
+			die( "Please stash files before attempting to push a release." );
 		}
 		next();
-	});
+	} );
 }
 
 function tagReleaseVersion( next ) {
-	git( [ "commit", "-a", "-m", "Tagging the " + releaseVersion + " release." ], function(){
-		git( [ "tag", releaseVersion ], next);
-	});
+	git( [ "commit", "-a", "-m", "Tagging the " + releaseVersion + " release." ], function() {
+		git( [ "tag", releaseVersion ], next );
+	} );
 }
 
 function updateVersions( next ) {
@@ -153,18 +153,18 @@ function gruntBuild( next ) {
 		}
 		log( stdout || "(no output)" );
 		next();
-	});
+	} );
 }
 
 function makeReleaseCopies( next ) {
 	finalFiles = {};
-	Object.keys( releaseFiles ).forEach(function( key ) {
+	Object.keys( releaseFiles ).forEach( function( key ) {
 		var builtFile = releaseFiles[ key ],
 			releaseFile = key.replace( /VER/g, releaseVersion );
 
 		copy( builtFile, releaseFile );
 		finalFiles[ releaseFile ] = builtFile;
-	});
+	} );
 	next();
 }
 
@@ -187,18 +187,18 @@ function setNextVersion( next ) {
 function uploadToCDN( next ) {
 	var cmds = [];
 
-	Object.keys( finalFiles ).forEach(function( name ) {
+	Object.keys( finalFiles ).forEach( function( name ) {
 		cmds.push(
-			function( nxt ){
+			function( nxt ) {
 				exec( "scp", [ name, scpURL ], nxt, skipRemote );
 			},
-			function( nxt ){
+			function( nxt ) {
 				exec( "curl", [ cdnURL + name + "?reload" ], nxt, skipRemote );
 			}
 		);
-	});
+	} );
 	cmds.push( next );
-	
+
 	steps.apply( this, cmds );
 }
 
@@ -211,11 +211,11 @@ function pushToRemote( next ) {
 function steps() {
 	var cur = 0,
 		steps = arguments;
-	(function next(){
-		process.nextTick(function(){
+	( function next() {
+		process.nextTick( function() {
 			steps[ cur++ ]( next );
-		});
-	})();
+		} );
+	} )();
 }
 
 function updatePackageVersion( ver, blobVer ) {
@@ -223,7 +223,7 @@ function updatePackageVersion( ver, blobVer ) {
 	blobVer = blobVer || ver;
 	pkg.version = ver;
 	pkg.author.url = setBlobVersion( pkg.author.url, blobVer );
-	pkg.licenses[0].url = setBlobVersion( pkg.licenses[0].url, blobVer );
+	pkg.licenses[ 0 ].url = setBlobVersion( pkg.licenses[ 0 ].url, blobVer );
 	writeJsonSync( packageFile, pkg );
 }
 
@@ -278,11 +278,11 @@ function git( args, fn, skip ) {
 
 function exec( cmd, args, fn, skip ) {
 	if ( dryrun || skip ) {
-		log( chalk.black.bgBlue( "# " + cmd + " " + args.join(" ") ) );
+		log( chalk.black.bgBlue( "# " + cmd + " " + args.join( " " ) ) );
 		fn();
 	} else {
-		log( chalk.green( cmd + " " + args.join(" ") ) );
-		child.execFile( cmd, args, { env: process.env }, 
+		log( chalk.green( cmd + " " + args.join( " " ) ) );
+		child.execFile( cmd, args, { env: process.env },
 			function( err, stdout, stderr ) {
 				if ( err ) {
 					die( stderr || stdout || err );
diff --git a/build/tasks/testswarm.js b/build/tasks/testswarm.js
new file mode 100644
index 00000000..8a7380c6
--- /dev/null
+++ b/build/tasks/testswarm.js
@@ -0,0 +1,58 @@
+"use strict";
+
+module.exports = function( grunt ) {
+	grunt.registerTask( "testswarm", function( commit, configFile, destName ) {
+		var jobName,
+			testswarm = require( "testswarm" ),
+			runs = {},
+			done = this.async(),
+			pull = /PR-(\d+)/.exec( commit ),
+			config = grunt.file.readJSON( configFile ).jquerymigrate,
+			tests = grunt.config( "tests" )[ destName ],
+			browserSets = destName || config.browserSets;
+
+		if ( browserSets[ 0 ] === "[" ) {
+
+			// We got an array, parse it
+			browserSets = JSON.parse( browserSets );
+		}
+
+		if ( pull ) {
+			jobName = "Pull <a href='https://github.com/jquery/jquery-migrate/pull/" +
+				pull[ 1 ] + "'>#" + pull[ 1 ] + "</a>";
+		} else {
+			jobName = "Commit <a href='https://github.com/jquery/jquery-migrate/commit/" +
+				commit + "'>" + commit.substr( 0, 10 ) + "</a>";
+		}
+
+		tests.forEach( function( test ) {
+			var pluginjQuery = test.split( "+" );
+			runs[ test ] = config.testUrl + commit + "/test/index.html?plugin=" +
+				pluginjQuery[ 0 ] + "&jquery=" + pluginjQuery[ 1 ];
+		} );
+
+		// TODO: create separate job for git so we can do different browsersets
+		testswarm.createClient( {
+			url: config.swarmUrl
+		} )
+		.addReporter( testswarm.reporters.cli )
+		.auth( {
+			id: config.authUsername,
+			token: config.authToken
+		} )
+		.addjob(
+			{
+				name: jobName,
+				runs: runs,
+				runMax: config.runMax,
+				browserSets: browserSets,
+				timeout: 1000 * 60 * 30
+			}, function( err, passed ) {
+				if ( err ) {
+					grunt.log.error( err );
+				}
+				done( passed );
+			}
+		);
+	} );
+};
diff --git a/package.json b/package.json
index 112b15c5..61697a4b 100644
--- a/package.json
+++ b/package.json
@@ -18,21 +18,60 @@
   },
   "license": "MIT",
   "scripts": {
-    "test": "grunt"
+    "build": "grunt build",
+    "test": "grunt test",
+    "ci": "grunt ci"
   },
   "devDependencies": {
     "chalk": "1.1.1",
+    "commitplease": "^2.3.0",
     "grunt": "~0.4.5",
+    "grunt-cli": "^0.1.13",
     "grunt-contrib-concat": "0.5.1",
     "grunt-contrib-jshint": "0.11.0",
     "grunt-contrib-uglify": "0.8.0",
     "grunt-contrib-watch": "0.6.1",
+    "grunt-coveralls": "^1.0.0",
     "grunt-git-authors": "3.0.0",
+    "grunt-jscs": "^2.7.0",
     "grunt-npmcopy": "0.1.0",
     "grunt-qunit-istanbul": "0.6.0",
     "jquery": "^2.1.3",
+    "phantomjs-polyfill": "0.0.1",
     "qunitjs": "1.17.1",
     "testswarm": "~1.1.0"
   },
-  "keywords": []
+  "keywords": [
+    "jquery",
+    "javascript",
+    "browser",
+    "plugin",
+    "migrate"
+  ],
+  "commitplease": {
+    "components": [
+      "Docs",
+      "Tests",
+      "Build",
+      "Release",
+      "Core",
+      "Ajax",
+      "Attributes",
+      "Callbacks",
+      "CSS",
+      "Data",
+      "Deferred",
+      "Deprecated",
+      "Dimensions",
+      "Effects",
+      "Event",
+      "Manipulation",
+      "Offset",
+      "Queue",
+      "Selector",
+      "Serialize",
+      "Traversing",
+      "Wrap"
+    ]
+  }
 }
diff --git a/src/ajax.js b/src/ajax.js
index 11c54ad4..c9ec6b2c 100644
--- a/src/ajax.js
+++ b/src/ajax.js
@@ -1,7 +1,7 @@
 
 // Ensure that $.ajax gets the new parseJSON defined in core.js
-jQuery.ajaxSetup({
+jQuery.ajaxSetup( {
 	converters: {
 		"text json": jQuery.parseJSON
 	}
-});
+} );
diff --git a/src/attributes.js b/src/attributes.js
index d4ba356f..9cb5c10e 100644
--- a/src/attributes.js
+++ b/src/attributes.js
@@ -1,5 +1,5 @@
 
-var attrFn = jQuery( "<input/>", { size: 1 } ).attr("size") && jQuery.attrFn,
+var attrFn = jQuery( "<input/>", { size: 1 } ).attr( "size" ) && jQuery.attrFn,
 	oldAttr = jQuery.attr,
 	valueAttrGet = jQuery.attrHooks.value && jQuery.attrHooks.value.get ||
 		function() { return null; },
@@ -10,7 +10,7 @@ var attrFn = jQuery( "<input/>", { size: 1 } ).attr("size") && jQuery.attrFn,
 	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
 	ruseDefault = /^(?:checked|selected)$/i;
 
-// jQuery.attrFn
+// JQuery.attrFn
 migrateWarnProp( jQuery, "attrFn", attrFn || {}, "jQuery.attrFn is deprecated" );
 
 jQuery.attr = function( elem, name, value, pass ) {
@@ -18,33 +18,40 @@ jQuery.attr = function( elem, name, value, pass ) {
 		nType = elem && elem.nodeType;
 
 	if ( pass ) {
+
 		// Since pass is used internally, we only warn for new jQuery
 		// versions where there isn't a pass arg in the formal params
 		if ( oldAttr.length < 4 ) {
-			migrateWarn("jQuery.fn.attr( props, pass ) is deprecated");
+			migrateWarn( "jQuery.fn.attr( props, pass ) is deprecated" );
 		}
 		if ( elem && !rnoAttrNodeType.test( nType ) &&
-			(attrFn ? name in attrFn : jQuery.isFunction(jQuery.fn[name])) ) {
+			( attrFn ? name in attrFn : jQuery.isFunction( jQuery.fn[ name ] ) ) ) {
 			return jQuery( elem )[ name ]( value );
 		}
 	}
 
 	// Warn if user tries to set `type`, since it breaks on IE 6/7/8; by checking
 	// for disconnected elements we don't warn on $( "<button>", { type: "button" } ).
-	if ( name === "type" && value !== undefined && rnoType.test( elem.nodeName ) && elem.parentNode ) {
-		migrateWarn("Can't change the 'type' of an input or button in IE 6/7/8");
+	if (
+		name === "type" &&
+		value !== undefined &&
+		rnoType.test( elem.nodeName ) &&
+		elem.parentNode
+	) {
+		migrateWarn( "Can't change the 'type' of an input or button in IE 6/7/8" );
 	}
 
 	// Restore boolHook for boolean property/attribute synchronization
 	if ( !jQuery.attrHooks[ lowerName ] && rboolean.test( lowerName ) ) {
 		jQuery.attrHooks[ lowerName ] = {
 			get: function( elem, name ) {
+
 				// Align boolean attributes with corresponding properties
 				// Fall back to attribute presence where some booleans are not supported
 				var attrNode,
 					property = jQuery.prop( elem, name );
 				return property === true || typeof property !== "boolean" &&
-					( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
+					( attrNode = elem.getAttributeNode( name ) ) && attrNode.nodeValue !== false ?
 
 					name.toLowerCase() :
 					undefined;
@@ -52,13 +59,16 @@ jQuery.attr = function( elem, name, value, pass ) {
 			set: function( elem, value, name ) {
 				var propName;
 				if ( value === false ) {
+
 					// Remove boolean attributes when set to false
 					jQuery.removeAttr( elem, name );
 				} else {
-					// value is true since we know at this point it's type boolean and not false
+
+					// Value is true since we know at this point it's type boolean and not false
 					// Set boolean attributes to the same name and set the DOM property
 					propName = jQuery.propFix[ name ] || name;
 					if ( propName in elem ) {
+
 						// Only set the IDL specifically if it already exists on the element
 						elem[ propName ] = true;
 					}
@@ -71,14 +81,16 @@ jQuery.attr = function( elem, name, value, pass ) {
 
 		// Warn only for attributes that can remain distinct from their properties post-1.9
 		if ( ruseDefault.test( lowerName ) ) {
-			migrateWarn( "jQuery.fn.attr('" + lowerName + "') might use property instead of attribute" );
+			migrateWarn(
+				"jQuery.fn.attr('" + lowerName + "') might use property instead of attribute"
+			);
 		}
 	}
 
 	return oldAttr.call( jQuery, elem, name, value );
 };
 
-// attrHooks: value
+// AttrHooks: value
 jQuery.attrHooks.value = {
 	get: function( elem, name ) {
 		var nodeName = ( elem.nodeName || "" ).toLowerCase();
@@ -86,7 +98,7 @@ jQuery.attrHooks.value = {
 			return valueAttrGet.apply( this, arguments );
 		}
 		if ( nodeName !== "input" && nodeName !== "option" ) {
-			migrateWarn("jQuery.fn.attr('value') no longer gets properties");
+			migrateWarn( "jQuery.fn.attr('value') no longer gets properties" );
 		}
 		return name in elem ?
 			elem.value :
@@ -98,8 +110,9 @@ jQuery.attrHooks.value = {
 			return valueAttrSet.apply( this, arguments );
 		}
 		if ( nodeName !== "input" && nodeName !== "option" ) {
-			migrateWarn("jQuery.fn.attr('value', val) no longer sets properties");
+			migrateWarn( "jQuery.fn.attr('value', val) no longer sets properties" );
 		}
+
 		// Does not return so that setAttribute is also used
 		elem.value = value;
 	}
diff --git a/src/core.js b/src/core.js
index 0713cd8f..aedd5fa3 100644
--- a/src/core.js
+++ b/src/core.js
@@ -4,6 +4,7 @@ var matched, browser,
 	oldParseJSON = jQuery.parseJSON,
 	rspaceAngle = /^\s*</,
 	rattrHash = /\[\s*\w+\s*[~|^$*]?=\s*(?![\s'"])[^#\]]*#/,
+
 	// Note: XSS check is done below after string is trimmed
 	rquickExpr = /^([^<]*)(<[\w\W]+>)([^>]*)$/;
 
@@ -12,24 +13,27 @@ jQuery.fn.init = function( selector, context, rootjQuery ) {
 	var match, ret;
 
 	if ( selector && typeof selector === "string" && !jQuery.isPlainObject( context ) &&
-			(match = rquickExpr.exec( jQuery.trim( selector ) )) && match[ 0 ] ) {
+			( match = rquickExpr.exec( jQuery.trim( selector ) ) ) && match[ 0 ] ) {
+
 		// This is an HTML string according to the "old" rules; is it still?
 		if ( !rspaceAngle.test( selector ) ) {
-			migrateWarn("$(html) HTML strings must start with '<' character");
+			migrateWarn( "$(html) HTML strings must start with '<' character" );
 		}
 		if ( match[ 3 ] ) {
-			migrateWarn("$(html) HTML text after last tag is ignored");
+			migrateWarn( "$(html) HTML text after last tag is ignored" );
 		}
 
 		// Consistently reject any HTML-like string starting with a hash (#9521)
 		// Note that this may break jQuery 1.6.x code that otherwise would work.
 		if ( match[ 0 ].charAt( 0 ) === "#" ) {
-			migrateWarn("HTML string cannot start with a '#' character");
-			jQuery.error("JQMIGRATE: Invalid selector string (XSS)");
+			migrateWarn( "HTML string cannot start with a '#' character" );
+			jQuery.error( "JQMIGRATE: Invalid selector string (XSS)" );
 		}
+
 		// Now process using loose rules; let pre-1.8 play too
 		if ( context && context.context ) {
-			// jQuery object as context; parseHTML expects a DOM object
+
+			// JQuery object as context; parseHTML expects a DOM object
 			context = context.context;
 		}
 		if ( jQuery.parseHTML ) {
@@ -41,7 +45,7 @@ jQuery.fn.init = function( selector, context, rootjQuery ) {
 
 	if ( selector === "#" ) {
 
-		// jQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0
+		// JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0
 		migrateWarn( "jQuery( '#' ) is not a valid selector" );
 		selector = [];
 
@@ -56,6 +60,7 @@ jQuery.fn.init = function( selector, context, rootjQuery ) {
 
 	// Fill in selector and context properties so .live() works
 	if ( selector && selector.selector !== undefined ) {
+
 		// A jQuery object, copy its properties
 		ret.selector = selector.selector;
 		ret.context = selector.context;
@@ -63,7 +68,7 @@ jQuery.fn.init = function( selector, context, rootjQuery ) {
 	} else {
 		ret.selector = typeof selector === "string" ? selector : "";
 		if ( selector ) {
-			ret.context = selector.nodeType? selector : context || document;
+			ret.context = selector.nodeType ? selector : context || document;
 		}
 	}
 
@@ -74,7 +79,7 @@ jQuery.fn.init.prototype = jQuery.fn;
 // Let $.parseJSON(falsy_value) return null
 jQuery.parseJSON = function( json ) {
 	if ( !json ) {
-		migrateWarn("jQuery.parseJSON requires a valid JSON string");
+		migrateWarn( "jQuery.parseJSON requires a valid JSON string" );
 		return null;
 	}
 	return oldParseJSON.apply( this, arguments );
@@ -87,7 +92,7 @@ jQuery.uaMatch = function( ua ) {
 		/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
 		/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
 		/(msie) ([\w.]+)/.exec( ua ) ||
-		ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
+		ua.indexOf( "compatible" ) < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
 		[];
 
 	return {
@@ -119,10 +124,14 @@ if ( !jQuery.browser ) {
 // Warn if the code tries to get jQuery.browser
 migrateWarnProp( jQuery, "browser", jQuery.browser, "jQuery.browser is deprecated" );
 
-// jQuery.boxModel deprecated in 1.3, jQuery.support.boxModel deprecated in 1.7
-jQuery.boxModel = jQuery.support.boxModel = (document.compatMode === "CSS1Compat");
+// JQuery.boxModel deprecated in 1.3, jQuery.support.boxModel deprecated in 1.7
+jQuery.boxModel = jQuery.support.boxModel = ( document.compatMode === "CSS1Compat" );
 migrateWarnProp( jQuery, "boxModel", jQuery.boxModel, "jQuery.boxModel is deprecated" );
-migrateWarnProp( jQuery.support, "boxModel", jQuery.support.boxModel, "jQuery.support.boxModel is deprecated" );
+migrateWarnProp(
+	jQuery.support,
+	"boxModel",
+	jQuery.support.boxModel, "jQuery.support.boxModel is deprecated"
+);
 
 jQuery.sub = function() {
 	function jQuerySub( selector, context ) {
@@ -140,7 +149,7 @@ jQuery.sub = function() {
 			jQuerySub( instance );
 	};
 	jQuerySub.fn.init.prototype = jQuerySub.fn;
-	var rootjQuerySub = jQuerySub(document);
+	var rootjQuerySub = jQuerySub( document );
 	migrateWarn( "jQuery.sub() is deprecated" );
 	return jQuerySub;
 };
diff --git a/src/css.js b/src/css.js
index 2f1e2c4b..3f690f92 100644
--- a/src/css.js
+++ b/src/css.js
@@ -16,7 +16,7 @@ if ( jQuery.swap ) {
 				return ret;
 			};
 		}
-	});
+	} );
 }
 
 jQuery.swap = function( elem, options, callback, args ) {
diff --git a/src/data.js b/src/data.js
index 6a90ef32..d5770fc7 100644
--- a/src/data.js
+++ b/src/data.js
@@ -3,14 +3,14 @@ var oldFnData = jQuery.fn.data;
 
 jQuery.fn.data = function( name ) {
 	var ret, evt,
-		elem = this[0];
+		elem = this[ 0 ];
 
 	// Handles 1.7 which has this behavior and 1.8 which doesn't
 	if ( elem && name === "events" && arguments.length === 1 ) {
 		ret = jQuery.data( elem, name );
 		evt = jQuery._data( elem, name );
 		if ( ( ret === undefined || ret === evt ) && evt !== undefined ) {
-			migrateWarn("Use of jQuery.fn.data('events') is deprecated");
+			migrateWarn( "Use of jQuery.fn.data('events') is deprecated" );
 			return evt;
 		}
 	}
diff --git a/src/deferred.js b/src/deferred.js
index 49146c73..f12292b9 100644
--- a/src/deferred.js
+++ b/src/deferred.js
@@ -1,16 +1,17 @@
 
-// jQuery 1.6 did not support Callbacks, do not warn there
+// JQuery 1.6 did not support Callbacks, do not warn there
 if ( jQuery.Callbacks ) {
 
 	var oldDeferred = jQuery.Deferred,
 		tuples = [
-			// action, add listener, callbacks, .then handlers, final state
-			[ "resolve", "done", jQuery.Callbacks("once memory"),
-				jQuery.Callbacks("once memory"), "resolved" ],
-			[ "reject", "fail", jQuery.Callbacks("once memory"),
-				jQuery.Callbacks("once memory"), "rejected" ],
-			[ "notify", "progress", jQuery.Callbacks("memory"),
-				jQuery.Callbacks("memory") ]
+
+			// Action, add listener, callbacks, .then handlers, final state
+			[ "resolve", "done", jQuery.Callbacks( "once memory" ),
+				jQuery.Callbacks( "once memory" ), "resolved" ],
+			[ "reject", "fail", jQuery.Callbacks( "once memory" ),
+				jQuery.Callbacks( "once memory" ), "rejected" ],
+			[ "notify", "progress", jQuery.Callbacks( "memory" ),
+				jQuery.Callbacks( "memory" ) ]
 		];
 
 	jQuery.Deferred = function( func ) {
@@ -22,13 +23,14 @@ if ( jQuery.Callbacks ) {
 
 			migrateWarn( "deferred.pipe() is deprecated" );
 
-			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(function() { bind to newDefer or newDefer.resolve })
+
+					// Deferred.done(function() { bind to newDefer or newDefer.resolve })
 					// deferred.fail(function() { bind to newDefer or newDefer.reject })
 					// deferred.progress(function() { bind to newDefer or newDefer.notify })
-					deferred[ tuple[1] ](function() {
+					deferred[ tuple[ 1 ] ]( function() {
 						var returned = fn && fn.apply( this, arguments );
 						if ( returned && jQuery.isFunction( returned.promise ) ) {
 							returned.promise()
@@ -41,10 +43,10 @@ if ( jQuery.Callbacks ) {
 								fn ? [ returned ] : arguments
 							);
 						}
-					});
-				});
+					} );
+				} );
 				fns = null;
-			}).promise();
+			} ).promise();
 
 		};
 
@@ -65,4 +67,4 @@ if ( jQuery.Callbacks ) {
 		return deferred;
 	};
 
-}
\ No newline at end of file
+}
diff --git a/src/event.js b/src/event.js
index 892fa63c..df9614ae 100644
--- a/src/event.js
+++ b/src/event.js
@@ -13,7 +13,7 @@ var eventAdd = jQuery.event.add,
 			return events;
 		}
 		if ( rhoverHack.test( events ) ) {
-			migrateWarn("'hover' pseudo-event is deprecated, use 'mouseenter mouseleave'");
+			migrateWarn( "'hover' pseudo-event is deprecated, use 'mouseenter mouseleave'" );
 		}
 		return events && events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
 	};
@@ -25,17 +25,22 @@ if ( jQuery.event.props && jQuery.event.props[ 0 ] !== "attrChange" ) {
 
 // Undocumented jQuery.event.handle was "deprecated" in jQuery 1.7
 if ( jQuery.event.dispatch ) {
-	migrateWarnProp( jQuery.event, "handle", jQuery.event.dispatch, "jQuery.event.handle is undocumented and deprecated" );
+	migrateWarnProp(
+		jQuery.event,
+		"handle",
+		jQuery.event.dispatch,
+		"jQuery.event.handle is undocumented and deprecated"
+	);
 }
 
 // Support for 'hover' pseudo-event and ajax event warnings
-jQuery.event.add = function( elem, types, handler, data, selector ){
+jQuery.event.add = function( elem, types, handler, data, selector ) {
 	if ( elem !== document && rajaxEvent.test( types ) ) {
 		migrateWarn( "AJAX events should be attached to document: " + types );
 	}
 	eventAdd.call( this, elem, hoverHack( types || "" ), handler, data, selector );
 };
-jQuery.event.remove = function( elem, types, handler, selector, mappedTypes ){
+jQuery.event.remove = function( elem, types, handler, selector, mappedTypes ) {
 	eventRemove.call( this, elem, hoverHack( types ) || "", handler, selector, mappedTypes );
 };
 
@@ -67,7 +72,7 @@ jQuery.each( [ "load", "unload", "error" ], function( _, name ) {
 		return this;
 	};
 
-});
+} );
 
 jQuery.fn.toggle = function( fn, fn2 ) {
 
@@ -75,13 +80,14 @@ jQuery.fn.toggle = function( fn, fn2 ) {
 	if ( !jQuery.isFunction( fn ) || !jQuery.isFunction( fn2 ) ) {
 		return oldToggle.apply( this, arguments );
 	}
-	migrateWarn("jQuery.fn.toggle(handler, handler...) is deprecated");
+	migrateWarn( "jQuery.fn.toggle(handler, handler...) is deprecated" );
 
 	// Save reference to arguments for access in closure
 	var args = arguments,
 		guid = fn.guid || jQuery.guid++,
 		i = 0,
 		toggler = function( event ) {
+
 			// Figure out which function to execute
 			var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
 			jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
@@ -89,11 +95,11 @@ jQuery.fn.toggle = function( fn, fn2 ) {
 			// Make sure that clicks stop
 			event.preventDefault();
 
-			// and execute the function
+			// And execute the function
 			return args[ lastToggle ].apply( this, arguments ) || false;
 		};
 
-	// link all the functions, so any of them can unbind this click handler
+	// Link all the functions, so any of them can unbind this click handler
 	toggler.guid = guid;
 	while ( i < args.length ) {
 		args[ i++ ].guid = guid;
@@ -103,7 +109,7 @@ jQuery.fn.toggle = function( fn, fn2 ) {
 };
 
 jQuery.fn.live = function( types, data, fn ) {
-	migrateWarn("jQuery.fn.live() is deprecated");
+	migrateWarn( "jQuery.fn.live() is deprecated" );
 	if ( oldLive ) {
 		return oldLive.apply( this, arguments );
 	}
@@ -112,7 +118,7 @@ jQuery.fn.live = function( types, data, fn ) {
 };
 
 jQuery.fn.die = function( types, fn ) {
-	migrateWarn("jQuery.fn.die() is deprecated");
+	migrateWarn( "jQuery.fn.die() is deprecated" );
 	if ( oldDie ) {
 		return oldDie.apply( this, arguments );
 	}
@@ -121,13 +127,13 @@ jQuery.fn.die = function( types, fn ) {
 };
 
 // Turn global events into document-triggered events
-jQuery.event.trigger = function( event, data, elem, onlyHandlers  ){
+jQuery.event.trigger = function( event, data, elem, onlyHandlers  ) {
 	if ( !elem && !rajaxEvent.test( event ) ) {
 		migrateWarn( "Global events are undocumented and deprecated" );
 	}
 	return eventTrigger.call( this,  event, data, elem || document, onlyHandlers  );
 };
-jQuery.each( ajaxEvents.split("|"),
+jQuery.each( ajaxEvents.split( "|" ),
 	function( _, name ) {
 		jQuery.event.special[ name ] = {
 			setup: function() {
@@ -136,8 +142,13 @@ jQuery.each( ajaxEvents.split("|"),
 				// The document needs no shimming; must be !== for oldIE
 				if ( elem !== document ) {
 					jQuery.event.add( document, name + "." + jQuery.guid, function() {
-						jQuery.event.trigger( name, Array.prototype.slice.call( arguments, 1 ), elem, true );
-					});
+						jQuery.event.trigger(
+							name,
+							Array.prototype.slice.call( arguments, 1 ),
+							elem,
+							true
+						);
+					} );
 					jQuery._data( this, name, jQuery.guid++ );
 				}
 				return false;
diff --git a/src/manipulation.js b/src/manipulation.js
index 54a2da87..ce1cd22c 100644
--- a/src/manipulation.js
+++ b/src/manipulation.js
@@ -4,12 +4,13 @@ var rscriptType = /\/(java|ecma)script/i;
 // Since jQuery.clean is used internally on older versions, we only shim if it's missing
 if ( !jQuery.clean ) {
 	jQuery.clean = function( elems, context, fragment, scripts ) {
+
 		// Set context per 1.8 logic
 		context = context || document;
-		context = !context.nodeType && context[0] || context;
+		context = !context.nodeType && context[ 0 ] || context;
 		context = context.ownerDocument || context;
 
-		migrateWarn("jQuery.clean() is deprecated");
+		migrateWarn( "jQuery.clean() is deprecated" );
 
 		var i, elem, handleScript, jsTags,
 			ret = [];
@@ -18,29 +19,42 @@ if ( !jQuery.clean ) {
 
 		// Complex logic lifted directly from jQuery 1.8
 		if ( fragment ) {
+
 			// Special handling of each script element
 			handleScript = function( elem ) {
+
 				// Check if we consider it executable
 				if ( !elem.type || rscriptType.test( elem.type ) ) {
-					// Detach the script and store it in the scripts array (if provided) or the fragment
+
+					// Detach the script and store it in
+					// the scripts array (if provided) or the fragment.
 					// Return truthy to indicate that it has been handled
 					return scripts ?
-						scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :
+						scripts.push(
+							elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :
 						fragment.appendChild( elem );
 				}
 			};
 
-			for ( i = 0; (elem = ret[i]) != null; i++ ) {
+			for ( i = 0; ( elem = ret[ i ] ) != null; i++ ) {
+
 				// Check if we're done after handling an executable script
 				if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) {
+
 					// Append to fragment and handle embedded scripts
 					fragment.appendChild( elem );
 					if ( typeof elem.getElementsByTagName !== "undefined" ) {
-						// handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration
-						jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript );
 
-						// Splice the scripts into ret after their former ancestor and advance our index beyond them
-						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
+						// HandleScript alters the DOM,
+						// so use jQuery.merge to ensure snapshot iteration
+						jsTags = jQuery.grep(
+							jQuery.merge( [], elem.getElementsByTagName( "script" ) ),
+							handleScript
+						);
+
+						// Splice the scripts into ret after their
+						// former ancestor and advance our index beyond them
+						ret.splice.apply( ret, [ i + 1, 0 ].concat( jsTags ) );
 						i += jsTags.length;
 					}
 				}
diff --git a/src/migrate.js b/src/migrate.js
index d2739e5c..a2e71c70 100644
--- a/src/migrate.js
+++ b/src/migrate.js
@@ -9,7 +9,7 @@ jQuery.migrateWarnings = [];
 
 // Show a message on the console so devs know we're active
 if ( !jQuery.migrateMute && window.console && window.console.log ) {
-	window.console.log("JQMIGRATE: Logging is active");
+	window.console.log( "JQMIGRATE: Logging is active" );
 }
 
 // Set to false to disable traces that appear with warnings
@@ -23,7 +23,7 @@ jQuery.migrateReset = function() {
 	jQuery.migrateWarnings.length = 0;
 };
 
-function migrateWarn( msg) {
+function migrateWarn( msg ) {
 	var console = window.console;
 	if ( !warnedAbout[ msg ] ) {
 		warnedAbout[ msg ] = true;
@@ -39,6 +39,7 @@ function migrateWarn( msg) {
 
 function migrateWarnProp( obj, prop, value, msg ) {
 	if ( Object.defineProperty ) {
+
 		// On ES5 browsers (non-oldIE), warn if the code tries to get prop;
 		// allow property to be overwritten in case some other plugin wants it
 		try {
@@ -53,9 +54,10 @@ function migrateWarnProp( obj, prop, value, msg ) {
 					migrateWarn( msg );
 					value = newValue;
 				}
-			});
+			} );
 			return;
-		} catch( err ) {
+		} catch ( err ) {
+
 			// IE8 is a dope about Object.defineProperty, can't warn there
 		}
 	}
@@ -66,6 +68,7 @@ function migrateWarnProp( obj, prop, value, msg ) {
 }
 
 if ( document.compatMode === "BackCompat" ) {
-	// jQuery has never supported or tested Quirks Mode
+
+	// JQuery has never supported or tested Quirks Mode
 	migrateWarn( "jQuery is not compatible with Quirks Mode" );
 }
diff --git a/src/traversing.js b/src/traversing.js
index dfc01a16..c231a907 100644
--- a/src/traversing.js
+++ b/src/traversing.js
@@ -2,7 +2,7 @@ var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack,
 	oldFind = jQuery.fn.find;
 
 jQuery.fn.andSelf = function() {
-	migrateWarn("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()");
+	migrateWarn( "jQuery.fn.andSelf() replaced by jQuery.fn.addBack()" );
 	return oldSelf.apply( this, arguments );
 };
 
diff --git a/test/ajax.js b/test/ajax.js
index e350c03f..063fc3da 100644
--- a/test/ajax.js
+++ b/test/ajax.js
@@ -1,5 +1,5 @@
 
-module("ajax");
+module( "ajax" );
 
 // Can't run this in PhantomJS because it's a local file
 if ( window.location.protocol !== "file:" ) {
@@ -9,30 +9,31 @@ if ( window.location.protocol !== "file:" ) {
 
 		stop();
 		jQuery.migrateReset();
-		jQuery.ajax({
+		jQuery.ajax( {
 			url: "data/empty.json",
 			dataType: "json",
 			cache: false,
 			success: function( data ) {
 				equal( data, null, "empty string converted to null" );
+
 				// We only generate 1 warning but jQuery < 1.11 uses .unload() internally
 				ok( jQuery.migrateWarnings.length > 0, "warned" );
 			},
 			error: function( xhr, msg ) {
-				ok( false, "error: "+ msg );
+				ok( false, "error: " + msg );
 			},
 			complete: function() {
 				start();
 			}
-		});
-	});
+		} );
+	} );
 
 	test( "jQuery.ajax() with 'null' JSON string", function() {
 		expect( 2 );
 
 		stop();
 		jQuery.migrateReset();
-		jQuery.ajax({
+		jQuery.ajax( {
 			url: "data/null.json",
 			dataType: "json",
 			cache: false,
@@ -41,20 +42,20 @@ if ( window.location.protocol !== "file:" ) {
 				equal( jQuery.migrateWarnings.length, 0, "did not warn" );
 			},
 			error: function( xhr, msg ) {
-				ok( false, "error: "+ msg );
+				ok( false, "error: " + msg );
 			},
 			complete: function() {
 				start();
 			}
-		});
-	});
+		} );
+	} );
 
 	test( "jQuery.ajax() with simple JSON string", function() {
 		expect( 2 );
 
 		stop();
 		jQuery.migrateReset();
-		jQuery.ajax({
+		jQuery.ajax( {
 			url: "data/simple.json",
 			dataType: "json",
 			cache: false,
@@ -63,11 +64,11 @@ if ( window.location.protocol !== "file:" ) {
 				equal( jQuery.migrateWarnings.length, 0, "did not warn" );
 			},
 			error: function( xhr, msg ) {
-				ok( false, "error: "+ msg );
+				ok( false, "error: " + msg );
 			},
 			complete: function() {
 				start();
 			}
-		});
-	});
-}
\ No newline at end of file
+		} );
+	} );
+}
diff --git a/test/attributes.js b/test/attributes.js
index 7f01e07c..873a8484 100644
--- a/test/attributes.js
+++ b/test/attributes.js
@@ -1,5 +1,5 @@
 
-module("attributes");
+module( "attributes" );
 
 test( "attrFn test", function() {
 	expect( 4 );
@@ -9,162 +9,172 @@ test( "attrFn test", function() {
 		equal( jQuery.attrFn.quack, undefined, "can read values from attrFn" );
 		jQuery.attrFn.quack = true;
 		equal( jQuery.attrFn.quack, true, "can assign new values to attrFn" );
-	});
-});
+	} );
+} );
 
 test( "warn if changing an input or button", function() {
 	expect( 4 );
 
-	var $div = jQuery("<div />"),
-		$input = jQuery("<input type=text />"),
-		$button = jQuery("<button type=button>click</button>");
+	var $div = jQuery( "<div />" ),
+		$input = jQuery( "<input type=text />" ),
+		$button = jQuery( "<button type=button>click</button>" );
 
 	expectNoWarning( "input type change", function() {
-		$div.appendTo("#qunit-fixture").attr( "type", "fancy" );
-	});
+		$div.appendTo( "#qunit-fixture" ).attr( "type", "fancy" );
+	} );
 
 	expectNoWarning( "$(html, props) signature", function() {
 		jQuery( "<button>", { type: "button" } );
-	});
+	} );
 
 	expectWarning( "input type change", function() {
 		try {
-			$input.appendTo("#qunit-fixture").attr( "type", "checkbox" );
+			$input.appendTo( "#qunit-fixture" ).attr( "type", "checkbox" );
 		} catch ( e ) { }
-	});
+	} );
 
 	expectWarning( "button type change", function() {
 		try {
-			$button.appendTo("#qunit-fixture").attr( "type", "submit" );
+			$button.appendTo( "#qunit-fixture" ).attr( "type", "submit" );
 		} catch ( e ) { }
-	});
-});
+	} );
+} );
 
 test( "attrHooks[\"value\"]", function() {
 	expect( 20 );
 
 	expectWarning( "input.attr('value')", 0, function() {
-		var input = jQuery("<input/>");
-		equal( input.attr("value"), "", "input.attr('value') returns initially empty property." );
-		input[0].value = "foo";
-		equal( input.attr("value"), "foo", "input.attr('value') returns property." );
-	});
+		var input = jQuery( "<input/>" );
+		equal( input.attr( "value" ), "", "input.attr('value') returns initially empty property." );
+		input[ 0 ].value = "foo";
+		equal( input.attr( "value" ), "foo", "input.attr('value') returns property." );
+	} );
 
 	expectWarning( "textarea.attr('value')", 1, function() {
-		equal( jQuery("#area1").attr("value"), "foobar", "textarea.attr('value') returns property." );
-	});
+		equal( jQuery( "#area1" ).attr( "value" ), "foobar",
+			"textarea.attr('value') returns property." );
+	} );
 
 	expectWarning( "input.attr('value', val)", 0, function() {
-		var el = jQuery("#text1").attr( "value", "foo" );
-		equal( el[0].getAttributeNode("value").value, "foo", "input.attr('value', val) sets attribute." );
-		equal( el[0].value, "foo", "input.attr('value', val) sets property." );
-	});
+		var el = jQuery( "#text1" ).attr( "value", "foo" );
+		equal( el[ 0 ].getAttributeNode( "value" ).value, "foo",
+			"input.attr('value', val) sets attribute." );
+		equal( el[ 0 ].value, "foo", "input.attr('value', val) sets property." );
+	} );
 
 	expectWarning( "textarea.attr('value', val)", 1, function() {
-		var el = jQuery("#area1").attr( "value", "foo" );
-		equal( el[0].value, "foo", "textarea.attr('value', val) sets property." );
-	});
+		var el = jQuery( "#area1" ).attr( "value", "foo" );
+		equal( el[ 0 ].value, "foo", "textarea.attr('value', val) sets property." );
+	} );
 
 	expectWarning( "select.attr('value', val)", 1, function() {
-		var el = jQuery("#select1").attr( "value", "2" );
-		equal( el[0].value, "2", "select.attr('value', val) sets property." );
-	});
+		var el = jQuery( "#select1" ).attr( "value", "2" );
+		equal( el[ 0 ].value, "2", "select.attr('value', val) sets property." );
+	} );
 
 	expectWarning( "button.attr(...)", 0, function() {
-		var button = jQuery("#button"),
-			majorMinorPatch = jQuery.fn.jquery.split(".");
+		var button = jQuery( "#button" ),
+			majorMinorPatch = jQuery.fn.jquery.split( "." );
 
 		// Respect the jQuery 1.9.0+ behavior changes
-		if ( majorMinorPatch[0] > 1 || ( majorMinorPatch[0] === "1" && majorMinorPatch[1] >= 9 ) ) {
-			equal( button.attr("value"), undefined, "button.attr('value') returns attribute." );
-			equal( button.attr( "value", "foo" ).attr("value"), "foo", "button.attr('value', val) sets attribute." );
+		if ( majorMinorPatch[ 0 ] > 1 ||
+		    ( majorMinorPatch[ 0 ] === "1" && majorMinorPatch[ 1 ] >= 9 )
+		) {
+			equal( button.attr( "value" ), undefined, "button.attr('value') returns attribute." );
+			equal( button.attr( "value", "foo" ).attr( "value" ), "foo",
+				"button.attr('value', val) sets attribute." );
 		} else {
-			ok( !button.attr("value"), "button.attr('value') is falsy." );
+			ok( !button.attr( "value" ), "button.attr('value') is falsy." );
 			ok( true, "Can't assert consistency of button.attr('value', val) on jQuery<1.9.0." );
 		}
-		equal( button.attr( "value", "bar" ).html(), "Button", "button.attr('value') doesn't affect contents" );
-	});
+		equal( button.attr( "value", "bar" ).html(), "Button",
+			"button.attr('value') doesn't affect contents" );
+	} );
 
 	expectWarning( "div.attr(...)", 2, function() {
-		var div = jQuery("#foo");
-		equal( div.attr("value"), undefined, "div.attr('value') returns attribute." );
-		equal( div.attr( "value", "bar" ).attr("value"), "bar", "div.attr('value', val) sets attribute." );
-		equal( div[0].value, "bar", "div.attr('value', val) sets property." );
-	});
-});
+		var div = jQuery( "#foo" );
+		equal( div.attr( "value" ), undefined, "div.attr('value') returns attribute." );
+		equal( div.attr( "value", "bar" ).attr( "value" ), "bar",
+			"div.attr('value', val) sets attribute." );
+		equal( div[ 0 ].value, "bar", "div.attr('value', val) sets property." );
+	} );
+} );
 
 test( "boolean attributes (boolHook)", function() {
 	expect( 42 );
 
 	expectWarning( ".attr(checked)", 1, function() {
-		jQuery("#check2").prop( "checked", true ).prop( "checked", false ).attr( "checked", true );
-		equal( document.getElementById("check2").checked, true, "Set checked attribute" );
-		equal( jQuery("#check2").prop("checked"), true, "Set checked attribute" );
-		equal( jQuery("#check2").attr("checked"), "checked", "Set checked attribute" );
-		jQuery("#check2").attr( "checked", false );
-		equal( document.getElementById("check2").checked, false, "Set checked attribute" );
-		equal( jQuery("#check2").prop("checked"), false, "Set checked attribute" );
-		equal( jQuery("#check2").attr("checked"), undefined, "Set checked attribute" );
-	});
+		jQuery( "#check2" ).prop( "checked", true )
+			.prop( "checked", false ).attr( "checked", true );
+		equal( document.getElementById( "check2" ).checked, true, "Set checked attribute" );
+		equal( jQuery( "#check2" ).prop( "checked" ), true, "Set checked attribute" );
+		equal( jQuery( "#check2" ).attr( "checked" ), "checked", "Set checked attribute" );
+		jQuery( "#check2" ).attr( "checked", false );
+		equal( document.getElementById( "check2" ).checked, false, "Set checked attribute" );
+		equal( jQuery( "#check2" ).prop( "checked" ), false, "Set checked attribute" );
+		equal( jQuery( "#check2" ).attr( "checked" ), undefined, "Set checked attribute" );
+	} );
 	expectWarning( ".attr(selected)", 1, function() {
-		jQuery("#option3d").prop( "selected", true ).prop( "selected", false ).attr( "selected", true );
-		equal( document.getElementById("option3d").selected, true, "Set selected attribute" );
-		equal( jQuery("#option3d").prop("selected"), true, "Set selected attribute" );
-		equal( jQuery("#option3d").attr("selected"), "selected", "Set selected attribute" );
-		jQuery("#option3d").attr( "selected", false );
-		equal( document.getElementById("option3d").selected, false, "Set selected attribute" );
-		equal( jQuery("#option3d").prop("selected"), false, "Set selected attribute" );
-		equal( jQuery("#option3d").attr("selected"), undefined, "Set selected attribute" );
-	});
+		jQuery( "#option3d" ).prop( "selected", true )
+			.prop( "selected", false ).attr( "selected", true );
+		equal( document.getElementById( "option3d" ).selected, true, "Set selected attribute" );
+		equal( jQuery( "#option3d" ).prop( "selected" ), true, "Set selected attribute" );
+		equal( jQuery( "#option3d" ).attr( "selected" ), "selected", "Set selected attribute" );
+		jQuery( "#option3d" ).attr( "selected", false );
+		equal( document.getElementById( "option3d" ).selected, false, "Set selected attribute" );
+		equal( jQuery( "#option3d" ).prop( "selected" ), false, "Set selected attribute" );
+		equal( jQuery( "#option3d" ).attr( "selected" ), undefined, "Set selected attribute" );
+	} );
 	expectWarning( ".attr(readonly)", 0, function() {
-		jQuery("#text1").attr( "readonly", true );
-		equal( document.getElementById("text1").readOnly, true, "Set readonly attribute" );
-		equal( jQuery("#text1").prop("readOnly"), true, "Set readonly attribute" );
-		equal( jQuery("#text1").attr("readonly"), "readonly", "Set readonly attribute" );
-		jQuery("#text1").attr( "readonly", false );
-		equal( document.getElementById("text1").readOnly, false, "Set readonly attribute" );
-		equal( jQuery("#text1").prop("readOnly"), false, "Set readonly attribute" );
-		equal( jQuery("#text1").attr("readonly"), undefined, "Set readonly attribute" );
-	});
-
-	jQuery("#check2").prop( "checked", true );
-	equal( document.getElementById("check2").checked, true, "Set checked attribute" );
-	equal( jQuery("#check2").prop("checked"), true, "Set checked attribute" );
-	equal( jQuery("#check2").attr("checked"), "checked", "Set checked attribute" );
-	jQuery("#check2").prop( "checked", false );
-	equal( document.getElementById("check2").checked, false, "Set checked attribute" );
-	equal( jQuery("#check2").prop("checked"), false, "Set checked attribute" );
-	equal( jQuery("#check2").attr("checked"), undefined, "Set checked attribute" );
-
-	jQuery("#check2").attr("checked", "checked");
-	equal( document.getElementById("check2").checked, true, "Set checked attribute with 'checked'" );
-	equal( jQuery("#check2").prop("checked"), true, "Set checked attribute" );
-	equal( jQuery("#check2").attr("checked"), "checked", "Set checked attribute" );
-
-
-	var $radios = jQuery("#checkedtest").find("input[type='radio']");
+		jQuery( "#text1" ).attr( "readonly", true );
+		equal( document.getElementById( "text1" ).readOnly, true, "Set readonly attribute" );
+		equal( jQuery( "#text1" ).prop( "readOnly" ), true, "Set readonly attribute" );
+		equal( jQuery( "#text1" ).attr( "readonly" ), "readonly", "Set readonly attribute" );
+		jQuery( "#text1" ).attr( "readonly", false );
+		equal( document.getElementById( "text1" ).readOnly, false, "Set readonly attribute" );
+		equal( jQuery( "#text1" ).prop( "readOnly" ), false, "Set readonly attribute" );
+		equal( jQuery( "#text1" ).attr( "readonly" ), undefined, "Set readonly attribute" );
+	} );
+
+	jQuery( "#check2" ).prop( "checked", true );
+	equal( document.getElementById( "check2" ).checked, true, "Set checked attribute" );
+	equal( jQuery( "#check2" ).prop( "checked" ), true, "Set checked attribute" );
+	equal( jQuery( "#check2" ).attr( "checked" ), "checked", "Set checked attribute" );
+	jQuery( "#check2" ).prop( "checked", false );
+	equal( document.getElementById( "check2" ).checked, false, "Set checked attribute" );
+	equal( jQuery( "#check2" ).prop( "checked" ), false, "Set checked attribute" );
+	equal( jQuery( "#check2" ).attr( "checked" ), undefined, "Set checked attribute" );
+
+	jQuery( "#check2" ).attr( "checked", "checked" );
+	equal( document.getElementById( "check2" ).checked, true,
+		"Set checked attribute with 'checked'" );
+	equal( jQuery( "#check2" ).prop( "checked" ), true, "Set checked attribute" );
+	equal( jQuery( "#check2" ).attr( "checked" ), "checked", "Set checked attribute" );
+
+	var $radios = jQuery( "#checkedtest" ).find( "input[type='radio']" );
 	$radios.eq( 1 ).click();
-	equal( $radios.eq( 1 ).prop("checked"), true, "Second radio was checked when clicked" );
-	equal( $radios.attr("checked"), $radios[ 0 ].checked ? "checked" : undefined, "Known booleans do not fall back to attribute presence (#10278)" );
-
-	jQuery("#text1").prop( "readOnly", true );
-	equal( document.getElementById("text1").readOnly, true, "Set readonly attribute" );
-	equal( jQuery("#text1").prop("readOnly"), true, "Set readonly attribute" );
-	equal( jQuery("#text1").attr("readonly"), "readonly", "Set readonly attribute" );
-	jQuery("#text1").prop( "readOnly", false );
-	equal( document.getElementById("text1").readOnly, false, "Set readonly attribute" );
-	equal( jQuery("#text1").prop("readOnly"), false, "Set readonly attribute" );
-	equal( jQuery("#text1").attr("readonly"), undefined, "Set readonly attribute" );
-
+	equal( $radios.eq( 1 ).prop( "checked" ), true, "Second radio was checked when clicked" );
+	equal( $radios.attr( "checked" ), $radios[ 0 ].checked ? "checked" : undefined,
+		"Known booleans do not fall back to attribute presence (#10278)" );
+
+	jQuery( "#text1" ).prop( "readOnly", true );
+	equal( document.getElementById( "text1" ).readOnly, true, "Set readonly attribute" );
+	equal( jQuery( "#text1" ).prop( "readOnly" ), true, "Set readonly attribute" );
+	equal( jQuery( "#text1" ).attr( "readonly" ), "readonly", "Set readonly attribute" );
+	jQuery( "#text1" ).prop( "readOnly", false );
+	equal( document.getElementById( "text1" ).readOnly, false, "Set readonly attribute" );
+	equal( jQuery( "#text1" ).prop( "readOnly" ), false, "Set readonly attribute" );
+	equal( jQuery( "#text1" ).attr( "readonly" ), undefined, "Set readonly attribute" );
 
 	// HTML5 boolean attributes
 	expectWarning( ".attr(HTML5)", 0, function() {
-		var $text = jQuery("#text1").attr({
+		var $text = jQuery( "#text1" ).attr( {
 			"autofocus": true,
 			"required": true
-		});
-		equal( $text.attr("autofocus"), "autofocus", "Set boolean attributes to the same name" );
-		equal( $text.attr( "autofocus", false ).attr("autofocus"), undefined, "Setting autofocus attribute to false removes it" );
-		equal( $text.attr("required"), "required", "Set boolean attributes to the same name" );
-	});
-});
+		} );
+		equal( $text.attr( "autofocus" ), "autofocus", "Set boolean attributes to the same name" );
+		equal( $text.attr( "autofocus", false ).attr( "autofocus" ), undefined,
+			"Setting autofocus attribute to false removes it" );
+		equal( $text.attr( "required" ), "required", "Set boolean attributes to the same name" );
+	} );
+} );
diff --git a/test/core.js b/test/core.js
index dc324ef7..9fc731ee 100644
--- a/test/core.js
+++ b/test/core.js
@@ -1,21 +1,22 @@
 
-module("core");
+module( "core" );
 
 test( "jQuery.migrateVersion", function( assert ) {
 	assert.expect( 1 );
 
 	assert.ok( /^\d+\.\d+\.[\w\-]+/.test( jQuery.migrateVersion ), "Version property" );
-});
+} );
 
 test( "jQuery(html, props)", function() {
 	expect( 3 );
 
 	var $el = jQuery( "<input/>", { name: "name", val: "value", size: 42 } );
 
-	equal( $el.attr("name"), "name", "Name attribute" );
-	equal( $el.attr("size"), jQuery.isEmptyObject(jQuery.attrFn) ? undefined : "42", "Size attribute" );
+	equal( $el.attr( "name" ), "name", "Name attribute" );
+	equal( $el.attr( "size" ),
+		jQuery.isEmptyObject( jQuery.attrFn ) ? undefined : "42", "Size attribute" );
 	equal( $el.val(), "value", "Call setter method" );
-});
+} );
 
 test( "jQuery(html) loose rules", function() {
 	expect( 33 );
@@ -46,12 +47,12 @@ test( "jQuery(html) loose rules", function() {
 		};
 
 	for ( w in nowarns ) {
-		expectNoWarning( w, generate( nowarns[w] ) );
+		expectNoWarning( w, generate( nowarns[ w ] ) );
 	}
 	for ( w in warns ) {
-		expectWarning( w, generate( warns[w] ) );
+		expectWarning( w, generate( warns[ w ] ) );
 	}
-});
+} );
 
 test( "jQuery( '#' )", function() {
 	expect( 2 );
@@ -59,8 +60,8 @@ test( "jQuery( '#' )", function() {
 	expectWarning( "Selector, through the jQuery constructor, nothing but hash", function() {
 		var set = jQuery( "#" );
 		equal( set.length, 0, "empty set" );
-	});
-});
+	} );
+} );
 
 test( "attribute selectors with naked '#'", function() {
 	expect( 6 );
@@ -70,39 +71,39 @@ test( "attribute selectors with naked '#'", function() {
 	expectWarning( "attribute equals", function() {
 		try {
 			jQuery( "a[href=#]" );
-		} catch( e ) {}
-	});
+		} catch ( e ) {}
+	} );
 
 	expectWarning( "attribute contains", function() {
 		try {
 			jQuery( "link[rel*=#stuff]" );
-		} catch( e ) {}
-	});
+		} catch ( e ) {}
+	} );
 
 	expectWarning( "attribute starts, with spaces", function() {
 		try {
 			jQuery( "a[href ^= #junk]" );
-		} catch( e ) {}
-	});
+		} catch ( e ) {}
+	} );
 
 	expectWarning( "attribute equals, hash not starting", function() {
 		try {
 			jQuery( "a[href=space#junk]" );
-		} catch( e ) {}
-	});
+		} catch ( e ) {}
+	} );
 
 	expectNoWarning( "attribute equals, with single quotes", function() {
 		try {
 			jQuery( "a[href='#junk']" );
-		} catch( e ) {}
-	});
+		} catch ( e ) {}
+	} );
 
 	expectNoWarning( "attribute equals, with double quotes", function() {
 		try {
 			jQuery( "a[href=\"#junk\"]" );
-		} catch( e ) {}
-	});
-});
+		} catch ( e ) {}
+	} );
+} );
 
 test( "selector state", function() {
 	expect( 18 );
@@ -121,11 +122,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" );
 
@@ -142,10 +143,10 @@ 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" );
-});
+} );
 
 test( "XSS injection", function() {
 	expect( 10 );
@@ -156,9 +157,9 @@ test( "XSS injection", function() {
 	// Bad HTML will throw on some supported versions
 	expectWarning( "leading hash", function() {
 		try {
-			jQuery("#yeah<p>RIGHT</p>");
+			jQuery( "#yeah<p>RIGHT</p>" );
 		} catch ( e ) {}
-	});
+	} );
 
 	// Don't expect HTML if there's a leading hash char; this is
 	// more strict than the 1.7 version but closes an XSS hole.
@@ -173,7 +174,7 @@ test( "XSS injection", function() {
 		}
 		equal( threw, expectThrow, "Throw on leading-hash HTML (treated as selector)" );
 		equal( window.XSS, false, "XSS" );
-	});
+	} );
 
 	expectWarning( "XSS with hash and leading space", function() {
 		var threw = false;
@@ -185,7 +186,7 @@ test( "XSS injection", function() {
 		}
 		equal( threw, expectThrow, "Throw on leading-hash HTML and space (treated as selector)" );
 		equal( window.XSS, false, "XSS" );
-	});
+	} );
 
 	expectWarning( "XSS via onerror inline handler", function() {
 		var threw = false;
@@ -197,42 +198,42 @@ test( "XSS injection", function() {
 		}
 		equal( threw, expectThrow, "Throw on leading-hash HTML (treated as selector)" );
 		stop();
-		setTimeout(function() {
+		setTimeout( function() {
 			equal( window.XSS, false, "XSS" );
 			start();
-		}, 1000);
-	});
-});
+		}, 1000 );
+	} );
+} );
 
-test( "jQuery( '<element>' ) usable on detached elements (#128)" , function() {
+test( "jQuery( '<element>' ) usable on detached elements (#128)", function() {
 	expect( 1 );
 
 	jQuery( "<a>" ).outerWidth();
 	ok( true, "No crash when operating on detached elements with window" );
-});
+} );
 
 test( "jQuery.parseJSON() falsy values", function() {
-	expect(6);
+	expect( 6 );
 
 	expectNoWarning( "valid JSON", function() {
-		jQuery.parseJSON("{\"a\":1}");
-	});
+		jQuery.parseJSON( "{\"a\":1}" );
+	} );
 	expectWarning( "actual null", function() {
-		jQuery.parseJSON(null);
-	});
+		jQuery.parseJSON( null );
+	} );
 	expectNoWarning( "string null", function() {
-		jQuery.parseJSON("null");
-	});
+		jQuery.parseJSON( "null" );
+	} );
 	expectWarning( "empty string", function() {
-		jQuery.parseJSON("");
-	});
+		jQuery.parseJSON( "" );
+	} );
 	expectWarning( "Boolean false", function() {
-		jQuery.parseJSON(false);
-	});
+		jQuery.parseJSON( false );
+	} );
 	expectWarning( "undefined", function() {
-		jQuery.parseJSON(undefined);
-	});
-});
+		jQuery.parseJSON( undefined );
+	} );
+} );
 
 test( "jQuery.browser", function() {
 	expect( 3 );
@@ -240,8 +241,8 @@ test( "jQuery.browser", function() {
 	( jQuery._definePropertyBroken ? expectNoWarning : expectWarning )( "browser", function() {
 		ok( jQuery.browser, "jQuery.browser present" );
 		ok( jQuery.browser.version, "have a browser version" );
-	});
-});
+	} );
+} );
 
 test( "jQuery.boxModel and jQuery.support.boxModel", function() {
 	expect( 3 );
@@ -249,10 +250,10 @@ test( "jQuery.boxModel and jQuery.support.boxModel", function() {
 	( jQuery._definePropertyBroken ? expectNoWarning : expectWarning )( "boxModel", 2, function() {
 		equal( jQuery.boxModel, true, "jQuery.boxModel is true (not in Quirks)" );
 		equal( jQuery.support.boxModel, true, "jQuery.support.boxModel is true (not in Quirks)" );
-	});
-});
+	} );
+} );
 
-test( "jQuery.sub() - Static Methods", function(){
+test( "jQuery.sub() - Static Methods", function() {
 	expect( 19 );
 
 	var Subclass, SubSubclass;
@@ -260,55 +261,68 @@ test( "jQuery.sub() - Static Methods", function(){
 	// Other warnings may be fired when props are copied
 	expectWarning( "jQuery.sub", function() {
 		Subclass = jQuery.sub();
-	});
+	} );
 
-	Subclass.extend({
+	Subclass.extend( {
 		"topLevelMethod": function() {return this.debug;},
 		"debug": false,
 		"config": {
 			"locale": "en_US"
 		},
-		"setup": function(config) {
-			this.extend(true, this["config"], config);
+		"setup": function( config ) {
+			this.extend( true, this.config, config );
 		}
-	});
-	Subclass.fn.extend({"subClassMethod": function() { return this;}});
+	} );
+	Subclass.fn.extend( { "subClassMethod": function() { return this;} } );
 
 	//Test Simple Subclass
-	ok(Subclass["topLevelMethod"]() === false, "Subclass.topLevelMethod thought debug was true");
-	ok(Subclass["config"]["locale"] === "en_US", Subclass["config"]["locale"] + " is wrong!");
-	deepEqual(Subclass["config"]["test"], undefined, "Subclass.config.test is set incorrectly");
-	equal(jQuery.ajax, Subclass.ajax, "The subclass failed to get all top level methods");
+	ok( Subclass.topLevelMethod() === false,
+		"Subclass.topLevelMethod thought debug was true"
+	);
+	ok( Subclass.config.locale === "en_US", Subclass.config.locale + " is wrong!" );
+	deepEqual( Subclass.config.test, undefined, "Subclass.config.test is set incorrectly" );
+	equal( jQuery.ajax, Subclass.ajax, "The subclass failed to get all top level methods" );
 
 	//Create a SubSubclass
 	SubSubclass = Subclass.sub();
 
 	//Make Sure the SubSubclass inherited properly
-	ok(SubSubclass["topLevelMethod"]() === false, "SubSubclass.topLevelMethod thought debug was true");
-	ok(SubSubclass["config"]["locale"] === "en_US", SubSubclass["config"]["locale"] + " is wrong!");
-	deepEqual(SubSubclass["config"]["test"], undefined, "SubSubclass.config.test is set incorrectly");
-	equal(jQuery.ajax, SubSubclass.ajax, "The subsubclass failed to get all top level methods");
+	ok( SubSubclass.topLevelMethod() === false,
+		"SubSubclass.topLevelMethod thought debug was true" );
+	ok( SubSubclass.config.locale === "en_US",
+		SubSubclass.config.locale + " is wrong!" );
+	deepEqual( SubSubclass.config.test, undefined,
+		"SubSubclass.config.test is set incorrectly" );
+	equal( jQuery.ajax, SubSubclass.ajax, "The subsubclass failed to get all top level methods" );
 
 	//Modify The Subclass and test the Modifications
-	SubSubclass.fn.extend({"subSubClassMethod": function() { return this;}});
-	SubSubclass["setup"]({"locale": "es_MX", "test": "worked"});
-	SubSubclass["debug"] = true;
+	SubSubclass.fn.extend( { "subSubClassMethod": function() { return this;} } );
+	SubSubclass.setup( { "locale": "es_MX", "test": "worked" } );
+	SubSubclass.debug = true;
 	SubSubclass.ajax = function() {return false;};
-	ok(SubSubclass["topLevelMethod"](), "SubSubclass.topLevelMethod thought debug was false");
-	deepEqual(SubSubclass(document)["subClassMethod"], Subclass.fn["subClassMethod"], "Methods Differ!");
-	ok(SubSubclass["config"]["locale"] === "es_MX", SubSubclass["config"]["locale"] + " is wrong!");
-	ok(SubSubclass["config"]["test"] === "worked", "SubSubclass.config.test is set incorrectly");
-	notEqual(jQuery.ajax, SubSubclass.ajax, "The subsubclass failed to get all top level methods");
+	ok( SubSubclass.topLevelMethod(), "SubSubclass.topLevelMethod thought debug was false" );
+	deepEqual( SubSubclass( document ).subClassMethod,
+		Subclass.fn.subClassMethod, "Methods Differ!" );
+	ok( SubSubclass.config.locale === "es_MX",
+		SubSubclass.config.locale + " is wrong!" );
+	ok( SubSubclass.config.test === "worked",
+		"SubSubclass.config.test is set incorrectly" );
+	notEqual( jQuery.ajax, SubSubclass.ajax,
+		"The subsubclass failed to get all top level methods" );
 
 	//This shows that the modifications to the SubSubClass did not bubble back up to it's superclass
-	ok(Subclass["topLevelMethod"]() === false, "Subclass.topLevelMethod thought debug was true");
-	ok(Subclass["config"]["locale"] === "en_US", Subclass["config"]["locale"] + " is wrong!");
-	deepEqual(Subclass["config"]["test"], undefined, "Subclass.config.test is set incorrectly");
-	deepEqual(Subclass(document)["subSubClassMethod"], undefined, "subSubClassMethod set incorrectly");
-	equal(jQuery.ajax, Subclass.ajax, "The subclass failed to get all top level methods");
-});
-
-test( "jQuery.sub() - .fn Methods", function(){
+	ok( Subclass.topLevelMethod() === false,
+		"Subclass.topLevelMethod thought debug was true" );
+	ok( Subclass.config.locale === "en_US",
+		Subclass.config.locale + " is wrong!" );
+	deepEqual( Subclass.config.test, undefined,
+		"Subclass.config.test is set incorrectly" );
+	deepEqual( Subclass( document ).subSubClassMethod,
+		undefined, "subSubClassMethod set incorrectly" );
+	equal( jQuery.ajax, Subclass.ajax, "The subclass failed to get all top level methods" );
+} );
+
+test( "jQuery.sub() - .fn Methods", function() {
 	expect( 378 );
 
 	var Subclass = jQuery.sub(),
@@ -317,7 +331,7 @@ test( "jQuery.sub() - .fn Methods", function(){
 		contexts = [ undefined, document, jQueryDocument ],
 		selectors = [ "body", "html,body", "<div></div>" ],
 		methodArguments = {
-			"eq": 1 ,
+			"eq": 1,
 			"add": document,
 			"end": undefined,
 			"has": undefined,
@@ -330,19 +344,20 @@ test( "jQuery.sub() - .fn Methods", function(){
 		return "jQueryDocument";
 	};
 
-	Subclass.fn.subMethod = function(){};
-	SubSubclass.fn.subSubMethod = function(){};
+	Subclass.fn.subMethod = function() {};
+	SubSubclass.fn.subSubMethod = function() {};
 
 	jQuery.each( contexts, function( i, context ) {
 			jQuery.each( selectors, function( i, selector ) {
-				jQuery.each( methodArguments, function( method, arg ){
+				jQuery.each( methodArguments, function( method, arg ) {
 
-				var description = "(\"" + selector + "\", " + context + ")." + method + "(" + (arg || "") + ")",
+				var description = "(\"" + selector + "\", " + context + ")." +
+						method + "(" + ( arg || "" ) + ")",
 					$instance = jQuery( selector, context )[ method ]( arg ),
 					$subInstance = Subclass( selector, context )[ method ]( arg ),
 					$subSubInstance = SubSubclass( selector, context )[ method ]( arg );
 
-				// jQuery
+				// JQuery
 				strictEqual( $instance.subMethod, undefined,
 					"jQuery" + description + " doesn't have Subclass methods" );
 				strictEqual( $instance.subSubMethod, undefined,
@@ -359,15 +374,15 @@ test( "jQuery.sub() - .fn Methods", function(){
 					"SubSubclass" + description + " has Subclass methods" );
 				strictEqual( $subSubInstance.subSubMethod, SubSubclass.fn.subSubMethod,
 					"SubSubclass" + description + " has SubSubclass methods" );
-			});
-		});
-	});
-});
+			} );
+		} );
+	} );
+} );
 
-test( ".size", function(){
+test( ".size", function() {
     expect( 1 );
 
     expectWarning( "size", function() {
         jQuery( "<div />" ).size();
-    });
-});
+    } );
+} );
diff --git a/test/css.js b/test/css.js
index 698bfc5d..6f3a53be 100644
--- a/test/css.js
+++ b/test/css.js
@@ -1,5 +1,5 @@
 
-module("css");
+module( "css" );
 
 test( "jQuery.swap()", function( assert ) {
 	assert.expect( 6 );
@@ -14,7 +14,7 @@ test( "jQuery.swap()", function( assert ) {
 			assert.equal( arg, 42, "arg was passed" );
 
 		}, [ 42 ] );
-	});
+	} );
 	assert.equal( div.style.borderRightWidth, "4px", "style was restored" );
 
 	expectNoWarning( "Internal swap() call", function() {
@@ -22,6 +22,6 @@ test( "jQuery.swap()", function( assert ) {
 			width = $fp.width();
 
 		assert.equal( $fp.hide().width(), width, "correct width" );
-	});
+	} );
 
-});
+} );
diff --git a/test/data.js b/test/data.js
index 5f4892be..bca70acd 100644
--- a/test/data.js
+++ b/test/data.js
@@ -1,35 +1,35 @@
 
-module("data");
+module( "data" );
 
 test( "basic .data() sanity check", function() {
 	expect( 4 );
 
-	var $foo = jQuery("#foo");
+	var $foo = jQuery( "#foo" );
 
-	equal( $foo.data("x"), undefined, "no data initially" );
+	equal( $foo.data( "x" ), undefined, "no data initially" );
 	$foo.data( "x", 42 );
-	equal( $foo.data("x"), 42, "set a numeric value" );
-	$foo.data( "x", function(){ alert("whoops"); });
-	equal( typeof $foo.data("x"), "function", "set a function value" );
-	$foo.removeData("x");
-	equal( $foo.data("x"), undefined, "data was removed" );
-});
+	equal( $foo.data( "x" ), 42, "set a numeric value" );
+	$foo.data( "x", function() { alert( "whoops" ); } );
+	equal( typeof $foo.data( "x" ), "function", "set a function value" );
+	$foo.removeData( "x" );
+	equal( $foo.data( "x" ), undefined, "data was removed" );
+} );
 
 test( "jQuery.fn.data('events')", function() {
 	expect( 6 );
 
-	var $foo = jQuery("#foo");
+	var $foo = jQuery( "#foo" );
 
 	expectNoWarning( "$.data('events')", function() {
-		equal( $foo.data("events"), undefined, "no events initially" );
-		$foo.data("events", 42);
-		equal( $foo.data("events"), 42, "got our own defined data" );
-		$foo.removeData("events");
-		equal( $foo.data("events"), undefined, "no events again" );
-	});
+		equal( $foo.data( "events" ), undefined, "no events initially" );
+		$foo.data( "events", 42 );
+		equal( $foo.data( "events" ), 42, "got our own defined data" );
+		$foo.removeData( "events" );
+		equal( $foo.data( "events" ), undefined, "no events again" );
+	} );
 	expectWarning( "$.data('events')", function() {
 		$foo.bind( "click", jQuery.noop );
-		equal( typeof $foo.data("events"), "object", "got undocumented events object" );
+		equal( typeof $foo.data( "events" ), "object", "got undocumented events object" );
 		$foo.unbind( "click", jQuery.noop );
-	});
-});
+	} );
+} );
diff --git a/test/deferred.js b/test/deferred.js
index 49149720..16610169 100644
--- a/test/deferred.js
+++ b/test/deferred.js
@@ -1,7 +1,7 @@
 
-module("deferred");
+module( "deferred" );
 
-// jQuery 1.6 did not support Callbacks, so skip the test there
+// JQuery 1.6 did not support Callbacks, so skip the test there
 if ( jQuery.Callbacks ) {
 
 	test( ".pipe() warnings", function( assert ) {
@@ -9,7 +9,7 @@ if ( jQuery.Callbacks ) {
 
 		var d = jQuery.Deferred(),
 			p = d.promise();
-		
+
 		function checkValue( v ) {
 			assert.equal( v, 1, "got correct value" );
 		}
@@ -17,16 +17,16 @@ if ( jQuery.Callbacks ) {
 		// Deferred
 		expectWarning( "pipe", function() {
 			d.pipe( checkValue );
-		});
+		} );
 
 		// Deferred's promise object
 		expectWarning( "pipe", function() {
 			p.pipe( checkValue );
-		});
+		} );
 
 		// Should happen synchronously for .pipe()
 		d.resolve( 1 );
-	});
+	} );
 
 	test( "[PIPE ONLY] jQuery.Deferred.pipe - filtering (fail)", function( assert ) {
 
@@ -36,34 +36,34 @@ if ( jQuery.Callbacks ) {
 			defer = jQuery.Deferred(),
 			piped = defer.pipe( null, function( a, b ) {
 				return a * b;
-			}),
+			} ),
 			done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
 
-		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 ).pipe( null, function() {
 			assert.strictEqual( value1, 2, "first reject value ok" );
 			assert.strictEqual( value2, 3, "second reject value ok" );
 			assert.strictEqual( value3, 6, "result of filter ok" );
 			done.pop().call();
-		});
+		} );
 
 		jQuery.Deferred().resolve().pipe( null, function() {
 			assert.ok( false, "then should not be called on resolve" );
-		}).then( done.pop() );
+		} ).then( done.pop() );
 
-		jQuery.Deferred().reject().pipe( null, jQuery.noop ).fail(function( value ) {
+		jQuery.Deferred().reject().pipe( null, jQuery.noop ).fail( function( value ) {
 			assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
 			done.pop().call();
-		});
-	});
+		} );
+	} );
 
 	test( "[PIPE ONLY] jQuery.Deferred.pipe - deferred (progress)", function( assert ) {
 
@@ -72,30 +72,30 @@ if ( jQuery.Callbacks ) {
 		var value1, value2, value3,
 			defer = jQuery.Deferred(),
 			piped = defer.pipe( null, null, function( a, b ) {
-				return jQuery.Deferred(function( defer ) {
+				return jQuery.Deferred( function( defer ) {
 					defer.resolve( a * b );
-				});
-			}),
+				} );
+			} ),
 			done = assert.async();
 
-		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 );
 
-		piped.done(function() {
+		piped.done( function() {
 			assert.strictEqual( value1, 2, "first progress value ok" );
 			assert.strictEqual( value2, 3, "second progress value ok" );
 			assert.strictEqual( value3, 6, "result of filter ok" );
 			done();
-		});
-	});
+		} );
+	} );
 
 	test( "[PIPE ONLY] jQuery.Deferred.pipe - context", function( assert ) {
 
@@ -105,46 +105,48 @@ if ( jQuery.Callbacks ) {
 			context = {},
 			done = jQuery.map( new Array( 4 ), function() { return assert.async(); } );
 
-		jQuery.Deferred().resolveWith( context, [ 2 ] ).pipe(function( value ) {
+		jQuery.Deferred().resolveWith( context, [ 2 ] ).pipe( function( value ) {
 			return value * 3;
-		}).done(function( value ) {
+		} ).done( function( value ) {
 			assert.strictEqual( this, context, "[PIPE ONLY] custom context correctly propagated" );
 			assert.strictEqual( value, 6, "proper value received" );
 			done.pop().call();
-		});
+		} );
 
-		jQuery.Deferred().resolve().pipe(function() {
-			return jQuery.Deferred().resolveWith(context);
-		}).done(function() {
+		jQuery.Deferred().resolve().pipe( function() {
+			return jQuery.Deferred().resolveWith( context );
+		} ).done( function() {
 			assert.strictEqual( this, context,
 				"custom context of returned deferred correctly propagated" );
 			done.pop().call();
-		});
+		} );
 
 		defer = jQuery.Deferred();
-		piped = defer.pipe(function( value ) {
+		piped = defer.pipe( function( value ) {
 			return value * 3;
-		});
+		} );
 
 		defer.resolve( 2 );
 
-		piped.done(function( value ) {
+		piped.done( function( value ) {
+
 			// `this` result changed between 1.8 and 1.9, so don't check it
 			assert.strictEqual( value, 6, "proper value received" );
 			done.pop().call();
-		});
+		} );
 
 		defer2 = jQuery.Deferred();
 		piped2 = defer2.pipe();
 
 		defer2.resolve( 2 );
 
-		piped2.done(function( value ) {
+		piped2.done( function( value ) {
+
 			// `this` result changed between 1.8 and 1.9, so don't check it
 			assert.strictEqual( value, 2, "proper value received (without passing function)" );
 			done.pop().call();
-		});
-	});
+		} );
+	} );
 
 	test( "isResolved() and isRejected()", function( assert ) {
 
@@ -154,31 +156,31 @@ if ( jQuery.Callbacks ) {
 
 		expectWarning( "isResolved unresolved", function() {
 			assert.strictEqual( defer.isResolved(), false, "isResolved pending" );
-		});
+		} );
 
 		expectWarning( "isRejected unresolved", function() {
 			assert.strictEqual( defer.isRejected(), false, "isRejected pending" );
-		});
+		} );
 
 		defer.resolve( 1 );
 
 		expectWarning( "isResolved resolved", function() {
 			assert.strictEqual( defer.isResolved(), true, "isResolved resolved" );
-		});
+		} );
 
 		expectWarning( "isResolved resolved", function() {
 			assert.strictEqual( defer.isRejected(), false, "isRejected resolved" );
-		});
+		} );
 
 		defer = jQuery.Deferred().reject( 1 );
 
 		expectWarning( "isResolved resolved", function() {
 			assert.strictEqual( defer.isResolved(), false, "isResolved rejected" );
-		});
+		} );
 
 		expectWarning( "isResolved resolved", function() {
 			assert.strictEqual( defer.isRejected(), true, "isRejected rejected" );
-		});
-	});
+		} );
+	} );
 
-}
\ No newline at end of file
+}
diff --git a/test/event.js b/test/event.js
index bca9fb32..55089259 100644
--- a/test/event.js
+++ b/test/event.js
@@ -1,5 +1,5 @@
 
-module("event");
+module( "event" );
 
 test( "live with non-null,defined data", function() {
 	expect( 3 );
@@ -9,21 +9,21 @@ test( "live with non-null,defined data", function() {
 		};
 
 	expectWarning( "live", function() {
-		jQuery("#foo").live("foo", handler);
-		jQuery("#foo").trigger("foo", 0);
-	});
+		jQuery( "#foo" ).live( "foo", handler );
+		jQuery( "#foo" ).trigger( "foo", 0 );
+	} );
 	expectWarning( "die", function() {
-		jQuery("#foo").die("foo", handler);
-	});
-});
+		jQuery( "#foo" ).die( "foo", handler );
+	} );
+} );
 
 test( "live/die(Object)", function() {
 	expect( 4 );
 
 	var clickCounter = 0,
 		mouseoverCounter = 0,
-		$p = jQuery("#firstp"),
-		$a = $p.find("a:first"),
+		$p = jQuery( "#firstp" ),
+		$a = $p.find( "a:first" ),
 		events = {
 			"click": function( event ) {
 				clickCounter += ( event.data || 1 );
@@ -33,7 +33,7 @@ test( "live/die(Object)", function() {
 			}
 		},
 		trigger = function() {
-			$a.trigger("click").trigger("mouseover");
+			$a.trigger( "click" ).trigger( "mouseover" );
 		};
 
 	$a.live( events );
@@ -48,62 +48,62 @@ test( "live/die(Object)", function() {
 	trigger();
 	equal( clickCounter, 2, "click after die" );
 	equal( mouseoverCounter, 2, "mouseover after die" );
-});
+} );
 
 test( "live immediate propagation", function() {
 	expect( 1 );
 
 	var lastClick,
-		$p = jQuery("#firstp"),
-		$a = $p.find("a:first");
+		$p = jQuery( "#firstp" ),
+		$a = $p.find( "a:first" );
 
 	lastClick = "";
-	$a.live( "click", function(e) {
+	$a.live( "click", function( e ) {
 		lastClick = "click1";
 		e.stopImmediatePropagation();
-	});
-	$a.live( "click", function(e) {
+	} );
+	$a.live( "click", function( e ) {
 		lastClick = "click2";
-	});
+	} );
 	$a.trigger( "click" );
 	equal( lastClick, "click1", "live stopImmediatePropagation" );
 	$a.die( "click" );
-});
+} );
 
 test( "live(name, false), die(name, false)", function() {
-	expect(3);
+	expect( 3 );
 
 	var main = 0;
-	jQuery("#qunit-fixture").live("click", function(e){ main++; });
-	jQuery("#ap").trigger("click");
+	jQuery( "#qunit-fixture" ).live( "click", function( e ) { main++; } );
+	jQuery( "#ap" ).trigger( "click" );
 	equal( main, 1, "Verify that the trigger happened correctly." );
 
 	main = 0;
-	jQuery("#ap").live("click", false);
-	jQuery("#ap").trigger("click");
+	jQuery( "#ap" ).live( "click", false );
+	jQuery( "#ap" ).trigger( "click" );
 	equal( main, 0, "Verify that no bubble happened." );
 
 	main = 0;
-	jQuery("#ap").die("click", false);
-	jQuery("#ap").trigger("click");
+	jQuery( "#ap" ).die( "click", false );
+	jQuery( "#ap" ).trigger( "click" );
 	equal( main, 1, "Verify that the trigger happened correctly." );
-	jQuery("#qunit-fixture").die("click");
-});
+	jQuery( "#qunit-fixture" ).die( "click" );
+} );
 
 test( ".live()/.die()", function() {
-	expect(66);
+	expect( 66 );
 
 	var submit = 0, div = 0, livea = 0, liveb = 0,
 		livec, lived, livee, elemDiv,
 		hash, event, clicked, container, called;
 
-	jQuery("div").live("submit", function(){ submit++; return false; });
-	jQuery("div").live("click", function(){ div++; });
-	jQuery("div#nothiddendiv").live("click", function(){ livea++; });
-	jQuery("div#nothiddendivchild").live("click", function(){ liveb++; });
+	jQuery( "div" ).live( "submit", function() { submit++; return false; } );
+	jQuery( "div" ).live( "click", function() { div++; } );
+	jQuery( "div#nothiddendiv" ).live( "click", function() { livea++; } );
+	jQuery( "div#nothiddendivchild" ).live( "click", function() { liveb++; } );
 
 	// Nothing should trigger on the body
-	jQuery("body").trigger("click");
+	jQuery( "body" ).trigger( "click" );
 	equal( submit, 0, "Click on body" );
 	equal( div, 0, "Click on body" );
 	equal( livea, 0, "Click on body" );
@@ -111,7 +111,7 @@ test( ".live()/.die()", function() {
 
 	// This should trigger two events
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendiv").trigger("click");
+	jQuery( "div#nothiddendiv" ).trigger( "click" );
 	equal( submit, 0, "Click on div" );
 	equal( div, 1, "Click on div" );
 	equal( livea, 1, "Click on div" );
@@ -119,7 +119,7 @@ test( ".live()/.die()", function() {
 
 	// This should trigger three events (w/ bubbling)
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendivchild").trigger("click");
+	jQuery( "div#nothiddendivchild" ).trigger( "click" );
 	equal( submit, 0, "Click on inner div" );
 	equal( div, 2, "Click on inner div" );
 	equal( livea, 1, "Click on inner div" );
@@ -127,7 +127,7 @@ test( ".live()/.die()", function() {
 
 	// This should trigger one submit
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendivchild").trigger("submit");
+	jQuery( "div#nothiddendivchild" ).trigger( "submit" );
 	equal( submit, 1, "Submit on div" );
 	equal( div, 0, "Submit on div" );
 	equal( livea, 0, "Submit on div" );
@@ -135,7 +135,7 @@ test( ".live()/.die()", function() {
 
 	// Make sure no other events were removed in the process
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendivchild").trigger("click");
+	jQuery( "div#nothiddendivchild" ).trigger( "click" );
 	equal( submit, 0, "die Click on inner div" );
 	equal( div, 2, "die Click on inner div" );
 	equal( livea, 1, "die Click on inner div" );
@@ -143,8 +143,8 @@ test( ".live()/.die()", function() {
 
 	// Now make sure that the removal works
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendivchild").die("click");
-	jQuery("div#nothiddendivchild").trigger("click");
+	jQuery( "div#nothiddendivchild" ).die( "click" );
+	jQuery( "div#nothiddendivchild" ).trigger( "click" );
 	equal( submit, 0, "die Click on inner div" );
 	equal( div, 2, "die Click on inner div" );
 	equal( livea, 1, "die Click on inner div" );
@@ -152,7 +152,7 @@ test( ".live()/.die()", function() {
 
 	// Make sure that the click wasn't removed too early
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendiv").trigger("click");
+	jQuery( "div#nothiddendiv" ).trigger( "click" );
 	equal( submit, 0, "die Click on inner div" );
 	equal( div, 1, "die Click on inner div" );
 	equal( livea, 1, "die Click on inner div" );
@@ -160,8 +160,10 @@ test( ".live()/.die()", function() {
 
 	// Make sure that stopPropgation doesn't stop live events
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	jQuery("div#nothiddendivchild").live("click", function(e){ liveb++; e.stopPropagation(); });
-	jQuery("div#nothiddendivchild").trigger("click");
+	jQuery( "div#nothiddendivchild" ).live( "click", function( e ) {
+		liveb++; e.stopPropagation();
+	} );
+	jQuery( "div#nothiddendivchild" ).trigger( "click" );
 	equal( submit, 0, "stopPropagation Click on inner div" );
 	equal( div, 1, "stopPropagation Click on inner div" );
 	equal( livea, 0, "stopPropagation Click on inner div" );
@@ -169,423 +171,435 @@ test( ".live()/.die()", function() {
 
 	// Make sure click events only fire with primary click
 	submit = 0; div = 0; livea = 0; liveb = 0;
-	event = jQuery.Event("click");
+	event = jQuery.Event( "click" );
 	event.button = 1;
-	jQuery("div#nothiddendiv").trigger(event);
+	jQuery( "div#nothiddendiv" ).trigger( event );
 
 	equal( livea, 0, "live secondary click" );
 
-	jQuery("div#nothiddendivchild").die("click");
-	jQuery("div#nothiddendiv").die("click");
-	jQuery("div").die("click");
-	jQuery("div").die("submit");
+	jQuery( "div#nothiddendivchild" ).die( "click" );
+	jQuery( "div#nothiddendiv" ).die( "click" );
+	jQuery( "div" ).die( "click" );
+	jQuery( "div" ).die( "submit" );
 
 	// Test binding with a different context
-	clicked = 0, container = jQuery("#qunit-fixture")[0];
-	jQuery("#foo", container).live("click", function(e){ clicked++; });
-	jQuery("div").trigger("click");
-	jQuery("#foo").trigger("click");
-	jQuery("#qunit-fixture").trigger("click");
-	jQuery("body").trigger("click");
+	clicked = 0, container = jQuery( "#qunit-fixture" )[ 0 ];
+	jQuery( "#foo", container ).live( "click", function( e ) { clicked++; } );
+	jQuery( "div" ).trigger( "click" );
+	jQuery( "#foo" ).trigger( "click" );
+	jQuery( "#qunit-fixture" ).trigger( "click" );
+	jQuery( "body" ).trigger( "click" );
 	equal( clicked, 2, "live with a context" );
 
 	// Test unbinding with a different context
-	jQuery("#foo", container).die("click");
-	jQuery("#foo").trigger("click");
-	equal( clicked, 2, "die with a context");
+	jQuery( "#foo", container ).die( "click" );
+	jQuery( "#foo" ).trigger( "click" );
+	equal( clicked, 2, "die with a context" );
 
 	// Test binding with event data
-	jQuery("#foo").live("click", true, function(e){ equal( e.data, true, "live with event data" ); });
-	jQuery("#foo").trigger("click").die("click");
+	jQuery( "#foo" ).live( "click", true,
+		function( e ) { equal( e.data, true, "live with event data" ); } );
+	jQuery( "#foo" ).trigger( "click" ).die( "click" );
 
 	// Test binding with trigger data
-	jQuery("#foo").live("click", function(e, data){ equal( data, true, "live with trigger data" ); });
-	jQuery("#foo").trigger("click", true).die("click");
+	jQuery( "#foo" ).live( "click", function( e, data ) {
+		equal( data, true, "live with trigger data" );
+	} );
+	jQuery( "#foo" ).trigger( "click", true ).die( "click" );
 
 	// Test binding with different this object
-	jQuery("#foo").live("click", jQuery.proxy(function(e){ equal( this.foo, "bar", "live with event scope" ); }, { foo: "bar" }));
-	jQuery("#foo").trigger("click").die("click");
+	jQuery( "#foo" ).live( "click", jQuery.proxy( function( e ) {
+		equal( this.foo, "bar", "live with event scope" );
+	}, { foo: "bar" } ) );
+	jQuery( "#foo" ).trigger( "click" ).die( "click" );
 
 	// Test binding with different this object, event data, and trigger data
-	jQuery("#foo").live("click", true, jQuery.proxy(function(e, data){
+	jQuery( "#foo" ).live( "click", true, jQuery.proxy( function( e, data ) {
 		equal( e.data, true, "live with with different this object, event data, and trigger data" );
-		equal( this["foo"], "bar", "live with with different this object, event data, and trigger data" );
-		equal( data, true, "live with with different this object, event data, and trigger data");
-	}, { "foo": "bar" }));
-	jQuery("#foo").trigger("click", true).die("click");
+		equal( this.foo, "bar",
+			"live with with different this object, event data, and trigger data" );
+		equal( data, true, "live with with different this object, event data, and trigger data" );
+	}, { "foo": "bar" } ) );
+	jQuery( "#foo" ).trigger( "click", true ).die( "click" );
 
 	// Verify that return false prevents default action
-	jQuery("#anchor2").live("click", function(){ return false; });
+	jQuery( "#anchor2" ).live( "click", function() { return false; } );
 	hash = window.location.hash;
-	jQuery("#anchor2").trigger("click");
+	jQuery( "#anchor2" ).trigger( "click" );
 	equal( window.location.hash, hash, "return false worked" );
-	jQuery("#anchor2").die("click");
+	jQuery( "#anchor2" ).die( "click" );
 
 	// Verify that .preventDefault() prevents default action
-	jQuery("#anchor2").live("click", function(e){ e.preventDefault(); });
+	jQuery( "#anchor2" ).live( "click", function( e ) { e.preventDefault(); } );
 	hash = window.location.hash;
-	jQuery("#anchor2").trigger("click");
+	jQuery( "#anchor2" ).trigger( "click" );
 	equal( window.location.hash, hash, "e.preventDefault() worked" );
-	jQuery("#anchor2").die("click");
+	jQuery( "#anchor2" ).die( "click" );
 
 	// Test binding the same handler to multiple points
 	called = 0;
-	function callback(){ called++; return false; }
+	function callback() { called++; return false; }
 
-	jQuery("#nothiddendiv").live("click", callback);
-	jQuery("#anchor2").live("click", callback);
+	jQuery( "#nothiddendiv" ).live( "click", callback );
+	jQuery( "#anchor2" ).live( "click", callback );
 
-	jQuery("#nothiddendiv").trigger("click");
+	jQuery( "#nothiddendiv" ).trigger( "click" );
 	equal( called, 1, "Verify that only one click occurred." );
 
 	called = 0;
-	jQuery("#anchor2").trigger("click");
+	jQuery( "#anchor2" ).trigger( "click" );
 	equal( called, 1, "Verify that only one click occurred." );
 
 	// Make sure that only one callback is removed
-	jQuery("#anchor2").die("click", callback);
+	jQuery( "#anchor2" ).die( "click", callback );
 
 	called = 0;
-	jQuery("#nothiddendiv").trigger("click");
+	jQuery( "#nothiddendiv" ).trigger( "click" );
 	equal( called, 1, "Verify that only one click occurred." );
 
 	called = 0;
-	jQuery("#anchor2").trigger("click");
+	jQuery( "#anchor2" ).trigger( "click" );
 	equal( called, 0, "Verify that no click occurred." );
 
 	// Make sure that it still works if the selector is the same,
 	// but the event type is different
-	jQuery("#nothiddendiv").live("foo", callback);
+	jQuery( "#nothiddendiv" ).live( "foo", callback );
 
 	// Cleanup
-	jQuery("#nothiddendiv").die("click", callback);
+	jQuery( "#nothiddendiv" ).die( "click", callback );
 
 	called = 0;
-	jQuery("#nothiddendiv").trigger("click");
+	jQuery( "#nothiddendiv" ).trigger( "click" );
 	equal( called, 0, "Verify that no click occurred." );
 
 	called = 0;
-	jQuery("#nothiddendiv").trigger("foo");
+	jQuery( "#nothiddendiv" ).trigger( "foo" );
 	equal( called, 1, "Verify that one foo occurred." );
 
 	// Cleanup
-	jQuery("#nothiddendiv").die("foo", callback);
+	jQuery( "#nothiddendiv" ).die( "foo", callback );
 
 	// Make sure we don't loose the target by DOM modifications
 	// after the bubble already reached the liveHandler
-	livec = 0, elemDiv = jQuery("#nothiddendivchild").html("<span></span>").get(0);
+	livec = 0, elemDiv = jQuery( "#nothiddendivchild" ).html( "<span></span>" ).get( 0 );
 
-	jQuery("#nothiddendivchild").live("click", function(e){ jQuery("#nothiddendivchild").html(""); });
-	jQuery("#nothiddendivchild").live("click", function(e){ if(e.target) {livec++;} });
+	jQuery( "#nothiddendivchild" ).live( "click", function( e ) {
+		jQuery( "#nothiddendivchild" ).html( "" );
+	} );
+	jQuery( "#nothiddendivchild" ).live( "click", function( e ) { if ( e.target ) {livec++;} } );
 
-	jQuery("#nothiddendiv span").click();
-	equal( jQuery("#nothiddendiv span").length, 0, "Verify that first handler occurred and modified the DOM." );
+	jQuery( "#nothiddendiv span" ).click();
+	equal( jQuery( "#nothiddendiv span" ).length, 0,
+		"Verify that first handler occurred and modified the DOM." );
 	equal( livec, 1, "Verify that second handler occurred even with nuked target." );
 
 	// Cleanup
-	jQuery("#nothiddendivchild").die("click");
+	jQuery( "#nothiddendivchild" ).die( "click" );
 
 	// Verify that .live() ocurs and cancel buble in the same order as
 	// we would expect .bind() and .click() without delegation
 	lived = 0, livee = 0;
 
-	// bind one pair in one order
-	jQuery("span#liveSpan1 a").live("click", function(){ lived++; return false; });
-	jQuery("span#liveSpan1").live("click", function(){ livee++; });
+	// Bind one pair in one order
+	jQuery( "span#liveSpan1 a" ).live( "click", function() { lived++; return false; } );
+	jQuery( "span#liveSpan1" ).live( "click", function() { livee++; } );
 
-	jQuery("span#liveSpan1 a").click();
+	jQuery( "span#liveSpan1 a" ).click();
 	equal( lived, 1, "Verify that only one first handler occurred." );
 	equal( livee, 0, "Verify that second handler doesn't." );
 
-	// and one pair in inverse
-	jQuery("span#liveSpan2").live("click", function(){ livee++; });
-	jQuery("span#liveSpan2 a").live("click", function(){ lived++; return false; });
+	// And one pair in inverse
+	jQuery( "span#liveSpan2" ).live( "click", function() { livee++; } );
+	jQuery( "span#liveSpan2 a" ).live( "click", function() { lived++; return false; } );
 
 	lived = 0;
 	livee = 0;
-	jQuery("span#liveSpan2 a").click();
+	jQuery( "span#liveSpan2 a" ).click();
 	equal( lived, 1, "Verify that only one first handler occurred." );
 	equal( livee, 0, "Verify that second handler doesn't." );
 
 	// Cleanup
-	jQuery("span#liveSpan1 a").die("click");
-	jQuery("span#liveSpan1").die("click");
-	jQuery("span#liveSpan2 a").die("click");
-	jQuery("span#liveSpan2").die("click");
+	jQuery( "span#liveSpan1 a" ).die( "click" );
+	jQuery( "span#liveSpan1" ).die( "click" );
+	jQuery( "span#liveSpan2 a" ).die( "click" );
+	jQuery( "span#liveSpan2" ).die( "click" );
 
 	// Test this, target and currentTarget are correct
-	jQuery("span#liveSpan1").live("click", function(e){
+	jQuery( "span#liveSpan1" ).live( "click", function( e ) {
 		equal( this.id, "liveSpan1", "Check the this within a live handler" );
-		equal( e.currentTarget.id, "liveSpan1", "Check the event.currentTarget within a live handler" );
+		equal( e.currentTarget.id, "liveSpan1",
+			"Check the event.currentTarget within a live handler" );
 		if ( e.delegateTarget !== undefined ) {
-			equal( e.delegateTarget, document, "Check the event.delegateTarget within a live handler" );
+			equal( e.delegateTarget, document,
+				"Check the event.delegateTarget within a live handler" );
 		} else {
 			ok( true, "No delegateTarget before jQuery 1.7" );
 		}
-		equal( e.target.nodeName.toUpperCase(), "A", "Check the event.target within a live handler" );
-	});
+		equal( e.target.nodeName.toUpperCase(), "A",
+			"Check the event.target within a live handler" );
+	} );
 
-	jQuery("span#liveSpan1 a").click();
+	jQuery( "span#liveSpan1 a" ).click();
 
-	jQuery("span#liveSpan1").die("click");
+	jQuery( "span#liveSpan1" ).die( "click" );
 
 	// Work with deep selectors
 	livee = 0;
 
-	function clickB(){ livee++; }
+	function clickB() { livee++; }
 
-	jQuery("#nothiddendiv div").live("click", function(){ livee++; });
-	jQuery("#nothiddendiv div").live("click", clickB);
-	jQuery("#nothiddendiv div").live("mouseover", function(){ livee++; });
+	jQuery( "#nothiddendiv div" ).live( "click", function() { livee++; } );
+	jQuery( "#nothiddendiv div" ).live( "click", clickB );
+	jQuery( "#nothiddendiv div" ).live( "mouseover", function() { livee++; } );
 
 	equal( livee, 0, "No clicks, deep selector." );
 
 	livee = 0;
-	jQuery("#nothiddendivchild").trigger("click");
+	jQuery( "#nothiddendivchild" ).trigger( "click" );
 	equal( livee, 2, "Click, deep selector." );
 
 	livee = 0;
-	jQuery("#nothiddendivchild").trigger("mouseover");
+	jQuery( "#nothiddendivchild" ).trigger( "mouseover" );
 	equal( livee, 1, "Mouseover, deep selector." );
 
-	jQuery("#nothiddendiv div").die("mouseover");
+	jQuery( "#nothiddendiv div" ).die( "mouseover" );
 
 	livee = 0;
-	jQuery("#nothiddendivchild").trigger("click");
+	jQuery( "#nothiddendivchild" ).trigger( "click" );
 	equal( livee, 2, "Click, deep selector." );
 
 	livee = 0;
-	jQuery("#nothiddendivchild").trigger("mouseover");
+	jQuery( "#nothiddendivchild" ).trigger( "mouseover" );
 	equal( livee, 0, "Mouseover, deep selector." );
 
-	jQuery("#nothiddendiv div").die("click", clickB);
+	jQuery( "#nothiddendiv div" ).die( "click", clickB );
 
 	livee = 0;
-	jQuery("#nothiddendivchild").trigger("click");
+	jQuery( "#nothiddendivchild" ).trigger( "click" );
 	equal( livee, 1, "Click, deep selector." );
 
-	jQuery("#nothiddendiv div").die("click");
+	jQuery( "#nothiddendiv div" ).die( "click" );
 
-	// blur a non-input element, we should force-fire its handlers
+	// Blur a non-input element, we should force-fire its handlers
 	// regardless of whether it's burring or not (unlike browsers)
-	jQuery("#nothiddendiv div")
-		.live("blur", function(){
+	jQuery( "#nothiddendiv div" )
+		.live( "blur", function() {
 			ok( true, "Live div trigger blur." );
-		})
-		.trigger("blur")
-		.die("blur");
-});
+		} )
+		.trigger( "blur" )
+		.die( "blur" );
+} );
 
-test( "die all bound events", function(){
-	expect(1);
+test( "die all bound events", function() {
+	expect( 1 );
 
-	var count = 0, div = jQuery("div#nothiddendivchild");
+	var count = 0, div = jQuery( "div#nothiddendivchild" );
 
-	div.live("click submit", function(){ count++; });
+	div.live( "click submit", function() { count++; } );
 	div.die();
 
-	div.trigger("click");
-	div.trigger("submit");
+	div.trigger( "click" );
+	div.trigger( "submit" );
 
 	equal( count, 0, "Make sure no events were triggered." );
-});
+} );
 
-test( "live with multiple events", function(){
-	expect(1);
+test( "live with multiple events", function() {
+	expect( 1 );
 
-	var count = 0, div = jQuery("div#nothiddendivchild");
+	var count = 0, div = jQuery( "div#nothiddendivchild" );
 
-	div.live("click submit", function(){ count++; });
+	div.live( "click submit", function() { count++; } );
 
-	div.trigger("click");
-	div.trigger("submit");
+	div.trigger( "click" );
+	div.trigger( "submit" );
 
 	equal( count, 2, "Make sure both the click and submit were triggered." );
 
-	// manually clean up events from elements outside the fixture
+	// Manually clean up events from elements outside the fixture
 	div.die();
-});
+} );
 
-test( "live with namespaces", function(){
-	expect(15);
+test( "live with namespaces", function() {
+	expect( 15 );
 
 	var count1 = 0, count2 = 0;
 
-	jQuery("#liveSpan1").live("foo.bar", function(e){
+	jQuery( "#liveSpan1" ).live( "foo.bar", function( e ) {
 		equal( e.namespace, "bar", "namespace is bar" );
 		count1++;
-	});
+	} );
 
-	jQuery("#liveSpan1").live("foo.zed", function(e){
+	jQuery( "#liveSpan1" ).live( "foo.zed", function( e ) {
 		equal( e.namespace, "zed", "namespace is zed" );
 		count2++;
-	});
+	} );
 
-	jQuery("#liveSpan1").trigger("foo.bar");
+	jQuery( "#liveSpan1" ).trigger( "foo.bar" );
 	equal( count1, 1, "Got live foo.bar" );
 	equal( count2, 0, "Got live foo.bar" );
 
 	count1 = 0; count2 = 0;
 
-	jQuery("#liveSpan1").trigger("foo.zed");
+	jQuery( "#liveSpan1" ).trigger( "foo.zed" );
 	equal( count1, 0, "Got live foo.zed" );
 	equal( count2, 1, "Got live foo.zed" );
 
-	//remove one
+	//Remove one
 	count1 = 0; count2 = 0;
 
-	jQuery("#liveSpan1").die("foo.zed");
-	jQuery("#liveSpan1").trigger("foo.bar");
+	jQuery( "#liveSpan1" ).die( "foo.zed" );
+	jQuery( "#liveSpan1" ).trigger( "foo.bar" );
 
 	equal( count1, 1, "Got live foo.bar after dieing foo.zed" );
 	equal( count2, 0, "Got live foo.bar after dieing foo.zed" );
 
 	count1 = 0; count2 = 0;
 
-	jQuery("#liveSpan1").trigger("foo.zed");
+	jQuery( "#liveSpan1" ).trigger( "foo.zed" );
 	equal( count1, 0, "Got live foo.zed" );
 	equal( count2, 0, "Got live foo.zed" );
 
-	//remove the other
-	jQuery("#liveSpan1").die("foo.bar");
+	//Remove the other
+	jQuery( "#liveSpan1" ).die( "foo.bar" );
 
 	count1 = 0; count2 = 0;
 
-	jQuery("#liveSpan1").trigger("foo.bar");
+	jQuery( "#liveSpan1" ).trigger( "foo.bar" );
 	equal( count1, 0, "Did not respond to foo.bar after dieing it" );
 	equal( count2, 0, "Did not respond to foo.bar after dieing it" );
 
-	jQuery("#liveSpan1").trigger("foo.zed");
+	jQuery( "#liveSpan1" ).trigger( "foo.zed" );
 	equal( count1, 0, "Did not trigger foo.zed again" );
 	equal( count2, 0, "Did not trigger foo.zed again" );
-});
+} );
 
-test( "live with change", function(){
-	expect(8);
+test( "live with change", function() {
+	expect( 8 );
 
 	var text, textChange, oldTextVal,
 		password, passwordChange, oldPasswordVal,
 		selectChange = 0,
 		checkboxChange = 0,
-		select = jQuery("select[name='S1']"),
-		checkbox = jQuery("#check2"),
-		checkboxFunction = function(){
+		select = jQuery( "select[name='S1']" ),
+		checkbox = jQuery( "#check2" ),
+		checkboxFunction = function() {
 			checkboxChange++;
 		};
 
-	select.live("change", function() {
+	select.live( "change", function() {
 		selectChange++;
-	});
-	checkbox.live("change", checkboxFunction);
+	} );
+	checkbox.live( "change", checkboxFunction );
 
-	// test click on select
+	// Test click on select
 
-	// second click that changed it
+	// Second click that changed it
 	selectChange = 0;
-	select[0].selectedIndex = select[0].selectedIndex ? 0 : 1;
-	select.trigger("change");
+	select[ 0 ].selectedIndex = select[ 0 ].selectedIndex ? 0 : 1;
+	select.trigger( "change" );
 	equal( selectChange, 1, "Change on click." );
 
-	// test keys on select
+	// Test keys on select
 	selectChange = 0;
-	select[0].selectedIndex = select[0].selectedIndex ? 0 : 1;
-	select.trigger("change");
+	select[ 0 ].selectedIndex = select[ 0 ].selectedIndex ? 0 : 1;
+	select.trigger( "change" );
 	equal( selectChange, 1, "Change on keyup." );
 
-	// test click on checkbox
-	checkbox.trigger("change");
+	// Test click on checkbox
+	checkbox.trigger( "change" );
 	equal( checkboxChange, 1, "Change on checkbox." );
 
-	// test blur/focus on text
-	text = jQuery("#name");
+	// Test blur/focus on text
+	text = jQuery( "#name" );
 	textChange = 0;
 	oldTextVal = text.val();
-	text.live("change", function() {
+	text.live( "change", function() {
 		textChange++;
-	});
+	} );
 
-	text.val(oldTextVal+"foo");
-	text.trigger("change");
+	text.val( oldTextVal + "foo" );
+	text.trigger( "change" );
 	equal( textChange, 1, "Change on text input." );
 
-	text.val(oldTextVal);
-	text.die("change");
+	text.val( oldTextVal );
+	text.die( "change" );
 
-	// test blur/focus on password
-	password = jQuery("#name");
+	// Test blur/focus on password
+	password = jQuery( "#name" );
 	passwordChange = 0;
 	oldPasswordVal = password.val();
-	password.live("change", function() {
+	password.live( "change", function() {
 		passwordChange++;
-	});
+	} );
 
-	password.val(oldPasswordVal + "foo");
-	password.trigger("change");
+	password.val( oldPasswordVal + "foo" );
+	password.trigger( "change" );
 	equal( passwordChange, 1, "Change on password input." );
 
-	password.val(oldPasswordVal);
-	password.die("change");
+	password.val( oldPasswordVal );
+	password.die( "change" );
 
-	// make sure die works
+	// Make sure die works
 
-	// die all changes
+	// Die all changes
 	selectChange = 0;
-	select.die("change");
-	select[0].selectedIndex = select[0].selectedIndex ? 0 : 1;
-	select.trigger("change");
+	select.die( "change" );
+	select[ 0 ].selectedIndex = select[ 0 ].selectedIndex ? 0 : 1;
+	select.trigger( "change" );
 	equal( selectChange, 0, "Die on click works." );
 
 	selectChange = 0;
-	select[0].selectedIndex = select[0].selectedIndex ? 0 : 1;
-	select.trigger("change");
+	select[ 0 ].selectedIndex = select[ 0 ].selectedIndex ? 0 : 1;
+	select.trigger( "change" );
 	equal( selectChange, 0, "Die on keyup works." );
 
-	// die specific checkbox
-	checkbox.die("change", checkboxFunction);
-	checkbox.trigger("change");
+	// Die specific checkbox
+	checkbox.die( "change", checkboxFunction );
+	checkbox.trigger( "change" );
 	equal( checkboxChange, 1, "Die on checkbox." );
-});
+} );
 
 test( "live with submit", function() {
-	expect(7);
+	expect( 7 );
 
 	var count1 = 0, count2 = 0;
 
-	jQuery("#testForm").live("submit", function(ev) {
+	jQuery( "#testForm" ).live( "submit", function( ev ) {
 		count1++;
 		ev.preventDefault();
-	});
+	} );
 
-	jQuery("body").live("submit", function(ev) {
+	jQuery( "body" ).live( "submit", function( ev ) {
 		count2++;
 		ev.preventDefault();
-	});
+	} );
 
-	jQuery("#testForm input[name=sub1]").submit();
+	jQuery( "#testForm input[name=sub1]" ).submit();
 	equal( count1, 1, "Verify form submit." );
 	equal( count2, 1, "Verify body submit." );
 
-	jQuery("#testForm input[name=sub1]").live("click", function(ev) {
+	jQuery( "#testForm input[name=sub1]" ).live( "click", function( ev ) {
 		ok( true, "cancelling submit still calls click handler" );
-	});
+	} );
 
-	jQuery("#testForm input[name=sub1]")[0].click();
+	jQuery( "#testForm input[name=sub1]" )[ 0 ].click();
 	equal( count1, 2, "Verify form submit." );
 	equal( count2, 2, "Verify body submit." );
 
-	jQuery("#testForm button[name=sub4]")[0].click();
+	jQuery( "#testForm button[name=sub4]" )[ 0 ].click();
 	equal( count1, 3, "Verify form submit." );
 	equal( count2, 3, "Verify body submit." );
 
-	jQuery("#testForm").die("submit");
-	jQuery("#testForm input[name=sub1]").die("click");
-	jQuery("body").die("submit");
-});
+	jQuery( "#testForm" ).die( "submit" );
+	jQuery( "#testForm input[name=sub1]" ).die( "click" );
+	jQuery( "body" ).die( "submit" );
+} );
 
 test( "live with special events", function() {
-	expect(13);
+	expect( 13 );
 
-	jQuery.event.special["foo"] = {
+	jQuery.event.special.foo = {
 		setup: function( data, namespaces, handler ) {
 			ok( true, "Setup run." );
 		},
@@ -604,32 +618,32 @@ test( "live with special events", function() {
 	};
 
 	// Run: setup, add
-	jQuery("#liveSpan1").live("foo.a", function(e){
+	jQuery( "#liveSpan1" ).live( "foo.a", function( e ) {
 		ok( true, "Handler 1 run." );
-	});
+	} );
 
 	// Run: add
-	jQuery("#liveSpan1").live("foo.b", function(e){
+	jQuery( "#liveSpan1" ).live( "foo.b", function( e ) {
 		ok( true, "Handler 2 run." );
-	});
+	} );
 
 	// Run: Handler 1, Handler 2, Default
-	jQuery("#liveSpan1").trigger("foo", 42);
+	jQuery( "#liveSpan1" ).trigger( "foo", 42 );
 
 	// Run: Handler 1, Default
-	jQuery("#liveSpan1").trigger("foo.a", 42);
+	jQuery( "#liveSpan1" ).trigger( "foo.a", 42 );
 
 	// Run: remove
-	jQuery("#liveSpan1").die("foo.a");
+	jQuery( "#liveSpan1" ).die( "foo.a" );
 
 	// Run: Handler 2, Default
-	jQuery("#liveSpan1").trigger("foo", 42);
+	jQuery( "#liveSpan1" ).trigger( "foo", 42 );
 
 	// Run: remove, teardown
-	jQuery("#liveSpan1").die("foo");
+	jQuery( "#liveSpan1" ).die( "foo" );
 
-	delete jQuery.event.special["foo"];
-});
+	delete jQuery.event.special.foo;
+} );
 
 test( "toggle(Function, Function, ...)", function() {
 	expect( 19 );
@@ -638,125 +652,129 @@ test( "toggle(Function, Function, ...)", function() {
 		count = 0,
 		first = 0,
 		turn = 0,
-		fn1 = function(e) { count++; },
-		fn2 = function(e) { count--; },
-		preventDefault = function(e) { e.preventDefault(); },
-		link = jQuery("#mark");
+		fn1 = function( e ) { count++; },
+		fn2 = function( e ) { count--; },
+		preventDefault = function( e ) { e.preventDefault(); },
+		link = jQuery( "#mark" );
 
 	expectNoWarning( "jQuery.fn.toggle visibility unaffected", function() {
-		jQuery("#foo").toggle( false );
-		ok( jQuery("#foo").is(":hidden"), ".toggle(Boolean) unaffected" );
-	});
+		jQuery( "#foo" ).toggle( false );
+		ok( jQuery( "#foo" ).is( ":hidden" ), ".toggle(Boolean) unaffected" );
+	} );
 
 	expectWarning( "jQuery.fn.toggle", function() {
-		link.click(preventDefault).click().toggle(fn1, fn2).click().click().click().click().click();
+		link.click( preventDefault ).click().toggle( fn1, fn2 )
+			.click().click().click().click().click();
 		equal( count, 1, "Check for toggle(fn, fn)" );
-	});
+	} );
 
-	jQuery("#firstp").toggle(function () {
-		equal(arguments.length, 4, "toggle correctly passes through additional triggered arguments, see #1701" );
-	}, function() {}).trigger("click", [ 1, 2, 3 ]);
+	jQuery( "#firstp" ).toggle( function() {
+		equal( arguments.length, 4,
+			"toggle correctly passes through additional triggered arguments, see #1701" );
+	}, function() {} ).trigger( "click", [ 1, 2, 3 ] );
 
-	jQuery("#simon1").one("click", function() {
+	jQuery( "#simon1" ).one( "click", function() {
 		ok( true, "Execute event only once" );
-		jQuery(this).toggle(function() {
-			equal( first++, 0, "toggle(Function,Function) assigned from within one('xxx'), see #1054" );
+		jQuery( this ).toggle( function() {
+			equal( first++, 0,
+				"toggle(Function,Function) assigned from within one('xxx'), see #1054" );
 		}, function() {
-			equal( first, 1, "toggle(Function,Function) assigned from within one('xxx'), see #1054" );
-		});
+			equal( first, 1,
+				"toggle(Function,Function) assigned from within one('xxx'), see #1054" );
+		} );
 		return false;
-	}).click().click().click();
+	} ).click().click().click();
 
 	fns = [
-		function(){
+		function() {
 			turn = 1;
 		},
-		function(){
+		function() {
 			turn = 2;
 		},
-		function(){
+		function() {
 			turn = 3;
 		}
 	];
 
-	$div = jQuery("<div>&nbsp;</div>").toggle( fns[0], fns[1], fns[2] );
+	$div = jQuery( "<div>&nbsp;</div>" ).toggle( fns[ 0 ], fns[ 1 ], fns[ 2 ] );
 	$div.click();
-	equal( turn, 1, "Trying toggle with 3 functions, attempt 1 yields 1");
+	equal( turn, 1, "Trying toggle with 3 functions, attempt 1 yields 1" );
 	$div.click();
-	equal( turn, 2, "Trying toggle with 3 functions, attempt 2 yields 2");
+	equal( turn, 2, "Trying toggle with 3 functions, attempt 2 yields 2" );
 	$div.click();
-	equal( turn, 3, "Trying toggle with 3 functions, attempt 3 yields 3");
+	equal( turn, 3, "Trying toggle with 3 functions, attempt 3 yields 3" );
 	$div.click();
-	equal( turn, 1, "Trying toggle with 3 functions, attempt 4 yields 1");
+	equal( turn, 1, "Trying toggle with 3 functions, attempt 4 yields 1" );
 	$div.click();
-	equal( turn, 2, "Trying toggle with 3 functions, attempt 5 yields 2");
+	equal( turn, 2, "Trying toggle with 3 functions, attempt 5 yields 2" );
 
-	$div.unbind("click",fns[0]);
-	data = jQuery._data( $div[0], "events" );
-	ok( !data, "Unbinding one function from toggle unbinds them all");
+	$div.unbind( "click", fns[ 0 ] );
+	data = jQuery._data( $div[ 0 ], "events" );
+	ok( !data, "Unbinding one function from toggle unbinds them all" );
 
-	// manually clean up detached elements
+	// Manually clean up detached elements
 	$div.remove();
 
 	// Test Multi-Toggles
 	a = [], b = [];
-	$div = jQuery("<div/>");
-	$div.toggle(function(){ a.push(1); }, function(){ a.push(2); });
+	$div = jQuery( "<div/>" );
+	$div.toggle( function() { a.push( 1 ); }, function() { a.push( 2 ); } );
 	$div.click();
-	deepEqual( a, [1], "Check that a click worked." );
+	deepEqual( a, [ 1 ], "Check that a click worked." );
 
-	$div.toggle(function(){ b.push(1); }, function(){ b.push(2); });
+	$div.toggle( function() { b.push( 1 ); }, function() { b.push( 2 ); } );
 	$div.click();
-	deepEqual( a, [1,2], "Check that a click worked with a second toggle." );
-	deepEqual( b, [1], "Check that a click worked with a second toggle." );
+	deepEqual( a, [ 1, 2 ], "Check that a click worked with a second toggle." );
+	deepEqual( b, [ 1 ], "Check that a click worked with a second toggle." );
 
 	$div.click();
-	deepEqual( a, [1,2,1], "Check that a click worked with a second toggle, second click." );
-	deepEqual( b, [1,2], "Check that a click worked with a second toggle, second click." );
+	deepEqual( a, [ 1, 2, 1 ], "Check that a click worked with a second toggle, second click." );
+	deepEqual( b, [ 1, 2 ], "Check that a click worked with a second toggle, second click." );
 
-	// manually clean up detached elements
+	// Manually clean up detached elements
 	$div.remove();
-});
+} );
 
 test( "error() event method", function() {
 	expect( 2 );
 
 	expectWarning( "jQuery.fn.error()", function() {
 		jQuery( "<img />" )
-			.error(function(){
+			.error( function() {
 				ok( true, "Triggered error event" );
-			})
+			} )
 			.error()
 			.unbind( "error" )
 			.error()
 			.remove();
-	});
-});
+	} );
+} );
 
 test( "load() and unload() event methods", function() {
 	expect( 5 );
 
 	expectWarning( "jQuery.fn.load()", function() {
 		jQuery( "<img />" )
-			.load(function(){
+			.load( function() {
 				ok( true, "Triggered load event" );
-			})
+			} )
 			.load()
 			.unbind( "load" )
 			.load()
 			.remove();
-	});
+	} );
 
 	expectWarning( "jQuery.fn.unload()", function() {
 		jQuery( "<img />" )
-			.unload(function(){
+			.unload( function() {
 				ok( true, "Triggered unload event" );
-			})
+			} )
 			.unload()
 			.unbind( "unload" )
 			.unload()
 			.remove();
-	});
+	} );
 
 	expectNoWarning( "ajax load", function() {
 		stop();
@@ -765,9 +783,9 @@ test( "load() and unload() event methods", function() {
 			.load( "not-found.file", function() {
 				jQuery( "#load138" ).remove();
 				start();
-			});
-	});
-});
+			} );
+	} );
+} );
 
 test( "hover pseudo-event", function() {
 	expect( 3 );
@@ -778,28 +796,29 @@ test( "hover pseudo-event", function() {
 		jQuery( "#firstp" )
 			.bind( "hovercraft", function() {
 				ok( false, "hovercraft is full of ills" );
-			})
+			} )
 			.bind( "click.hover.me.not", function( e ) {
-				equal( e.handleObj.namespace, "hover.me.not", "hover hack doesn't mangle namespaces" );
-			})
-			.bind("hover", function( e ) {
+				equal( e.handleObj.namespace,
+					"hover.me.not", "hover hack doesn't mangle namespaces" );
+			} )
+			.bind( "hover", function( e ) {
 				if ( e.type === "mouseenter" ) {
 					balance++;
 				} else if ( e.type === "mouseleave" ) {
 					balance--;
 				} else {
-					ok( false, "hover pseudo: unknown event type "+e.type );
+					ok( false, "hover pseudo: unknown event type " + e.type );
 				}
-			})
-			.trigger("click")
-			.trigger("mouseenter")
-			.trigger("mouseleave")
-			.unbind("hover")
-			.trigger("mouseenter");
+			} )
+			.trigger( "click" )
+			.trigger( "mouseenter" )
+			.trigger( "mouseleave" )
+			.unbind( "hover" )
+			.trigger( "mouseenter" );
 
 		equal( balance, 0, "hover pseudo-event" );
-	});
-});
+	} );
+} );
 
 test( "ready event", function() {
 	expect( 4 );
@@ -807,19 +826,19 @@ test( "ready event", function() {
 	expectWarning( "Setting a ready event", 1, function() {
 		jQuery( document ).bind( "ready", function() {
 			ok( true, "ready event was triggered" );
-		})
+		} )
 		.trigger( "ready" )
 		.unbind( "ready" );
-	});
+	} );
 
 	expectNoWarning( "Custom ready event not on document", 1, function() {
 		jQuery( "#foo" ).bind( "ready", function( e ) {
 			ok( true, "custom ready event was triggered" );
-		})
+		} )
 		.trigger( "ready" )
 		.unbind( "ready" );
-	});
-});
+	} );
+} );
 
 test( "global events not on document", function() {
 	expect( 11 );
@@ -830,26 +849,27 @@ test( "global events not on document", function() {
 		// Attach to random element, just like old times
 		jQuery( "#first" ).bind( events, function( e ) {
 			ok( true, e.type + " on #first" );
-		});
+		} );
 
 		// Ensure attach to document still fires
 		jQuery( document ).bind( events, function( e ) {
 			ok( true, e.type + " on document" );
-		});
+		} );
 		stop();
 
-		jQuery.ajax({
+		jQuery.ajax( {
 			url: "index.html",
 			complete: function() {
+
 				// Give events a chance to fire before we remove them
-				setTimeout(function() {
+				setTimeout( function() {
 					jQuery( "#first" ).add( document ).unbind( events );
 					setTimeout( start, 10 );
 				}, 10 );
 			}
-		});
-	});
-});
+		} );
+	} );
+} );
 
 test( "event args on non-document ajax events (#113)", function() {
 
@@ -859,17 +879,17 @@ test( "event args on non-document ajax events (#113)", function() {
 	jQuery( "#first" ).bind( "ajaxError", function( e, jqXHR, options ) {
 		equal( arguments.length, 4, "passed all args" );
 		equal( options.url, "not_found_404.html", "matched URL" );
-	});
+	} );
 
 	stop();
-	jQuery.ajax({
+	jQuery.ajax( {
 		url: "not_found_404.html",
 		complete: function() {
 			jQuery( "#first" ).unbind( "ajaxError" );
 			setTimeout( start, 10 );
 		}
-	});
-});
+	} );
+} );
 
 // Support: IE<=8
 // Need ES5 Object.defineProperty() to catch property access
@@ -879,21 +899,21 @@ if ( jQuery.event.dispatch && Object.defineProperties ) {
 		expect( 2 );
 
 		var matched = 0,
-			container = document.getElementById("foo"),
-			target = document.getElementById("anchor2");
+			container = document.getElementById( "foo" ),
+			target = document.getElementById( "anchor2" );
 
-		jQuery("#foo").bind( "click", function() {
+		jQuery( "#foo" ).bind( "click", function() {
 			matched++;
-		});
+		} );
 
 		expectWarning( "jQuery.event.handle", function() {
 			jQuery.event.handle.call(
 				container,
-				new jQuery.Event( "click", { target: target })
+				new jQuery.Event( "click", { target: target } )
 			);
-		});
+		} );
 
 		equal( matched, 1, "Event dispatched" );
-	});
+	} );
 
 }
diff --git a/test/migrate.js b/test/migrate.js
index 244bc747..314fa4a6 100644
--- a/test/migrate.js
+++ b/test/migrate.js
@@ -1,6 +1,6 @@
 
 // Don't spew on in the console window when we build
-if ( navigator.userAgent.indexOf("PhantomJS") >= 0 ) {
+if ( navigator.userAgent.indexOf( "PhantomJS" ) >= 0 ) {
 	jQuery.migrateMute = true;
 }
 
@@ -26,11 +26,14 @@ function expectWarning( name, expected, fn ) {
 
 	// Failure; use deepEqual to show the warnings that *were* generated and the expectation
 	} else {
-		deepEqual( jQuery.migrateWarnings, "<warnings: " + ( expected || "1+" ) + ">", name + ": warned" );
+		deepEqual( jQuery.migrateWarnings,
+			"<warnings: " + ( expected || "1+" ) + ">", name + ": warned"
+		);
 	}
 }
 
 function expectNoWarning( name, expected, fn ) {
+
 	// Expected is present only for signature compatibility with expectWarning
 	return expectWarning( name, 0, fn || expected );
 }
diff --git a/test/testinit.js b/test/testinit.js
index d93d4200..28fb2db4 100644
--- a/test/testinit.js
+++ b/test/testinit.js
@@ -13,7 +13,7 @@ TestManager = {
 			urlTag = this.projects[ projectName ].urlTag,
 			matcher = new RegExp( "\\b" + urlTag + "=([^&]+)" ),
 			projectRoot = isSelf ? ".." : "../../" + projectName,
-			version = ( matcher.exec( document.location.search ) || {} )[1] || defaultVersion;
+			version = ( matcher.exec( document.location.search ) || {} )[ 1 ] || defaultVersion;
 
 		if ( version === "dev" ) {
 			file = projectRoot + "/dist/" + projectName + ".js";
@@ -24,14 +24,14 @@ TestManager = {
 		} else {
 			file = version;
 		}
-		this.loaded.push({
+		this.loaded.push( {
 			projectName: projectName,
 			tag: version,
 			file: file
-		});
+		} );
 
 		// Prevents a jshint warning about eval-like behavior of document.write
-		document["write"]( "<script src='" + file + "'></script>" );
+		document.write( "<script src='" + file + "'></script>" );
 	},
 	init: function( projects ) {
 		var p, project;
@@ -42,11 +42,11 @@ TestManager = {
 		// Set the list of projects, including the project version choices.
 		for ( p in projects ) {
 			project = projects[ p ];
-			QUnit.config.urlConfig.push({
+			QUnit.config.urlConfig.push( {
 				label: p,
 				id: project.urlTag,
-				value: project.choices.split(",")
-			});
+				value: project.choices.split( "," )
+			} );
 		}
 	}
 };
@@ -54,6 +54,7 @@ TestManager = {
 /**
  * QUnit configuration
  */
+
 // Max time for async tests until it aborts test
 // and start()'s the next test.
 QUnit.config.testTimeout = 20 * 1000; // 20 seconds
@@ -64,14 +65,15 @@ QUnit.config.requireExpects = true;
 /**
  * Load the TestSwarm listener if swarmURL is in the address.
  */
-(function() {
+( function() {
 	var url = window.location.search;
-	url = decodeURIComponent( url.slice( url.indexOf("swarmURL=") + "swarmURL=".length ) );
+	url = decodeURIComponent( url.slice( url.indexOf( "swarmURL=" ) + "swarmURL=".length ) );
 
-	if ( !url || url.indexOf("http") !== 0 ) {
+	if ( !url || url.indexOf( "http" ) !== 0 ) {
 		return;
 	}
 
-	document.write("<scr" + "ipt src='http://swarm.jquery.org/js/inject.js?" + (new Date()).getTime() + "'></scr" + "ipt>");
-})();
+	document.write( "<scr" + "ipt src='http://swarm.jquery.org/js/inject.js?" +
+		( new Date() ).getTime() + "'></scr" + "ipt>" );
+} )();
 
diff --git a/test/traversing.js b/test/traversing.js
index 9dab8b09..e593fea3 100644
--- a/test/traversing.js
+++ b/test/traversing.js
@@ -1,10 +1,10 @@
 
 module( "traversing" );
 
-test( ".andSelf", function(){
+test( ".andSelf", function() {
     expect( 1 );
 
     expectWarning( "andSelf", function() {
-        jQuery( "<div id='outer'><div id='inner'></div></div>").find( ".inner").andSelf();
-    });
-});
+        jQuery( "<div id='outer'><div id='inner'></div></div>" ).find( ".inner" ).andSelf();
+    } );
+} );