From a8d1549b100067776a598cc3fb0b6bd55c0fd9f5 Mon Sep 17 00:00:00 2001
From: Aaron Jorbin <aaron@jorb.in>
Date: Sat, 20 Feb 2016 19:54:03 +0000
Subject: [PATCH] update qunit to 1.21.0

---
 tests/js/index.html                           |   4 +-
 .../{qunit-1.19.0.css => qunit-1.21.0.css}    |  24 +-
 .../{qunit-1.19.0.js => qunit-1.21.0.js}      | 712 +++++++++++-------
 3 files changed, 456 insertions(+), 284 deletions(-)
 rename tests/js/vendor/{qunit-1.19.0.css => qunit-1.21.0.css} (89%)
 rename tests/js/vendor/{qunit-1.19.0.js => qunit-1.21.0.js} (89%)

diff --git a/tests/js/index.html b/tests/js/index.html
index de5a844789..a1c51ec451 100644
--- a/tests/js/index.html
+++ b/tests/js/index.html
@@ -5,8 +5,8 @@
 	<title>Fieldmanager QUnit Test Suite</title>
 
 	<!-- QUnit -->
-	<link rel="stylesheet" href="vendor/qunit-1.19.0.css">
-	<script src="vendor/qunit-1.19.0.js"></script>
+	<link rel="stylesheet" href="vendor/qunit-1.21.0.css">
+	<script src="vendor/qunit-1.21.0.js"></script>
 
 	<script>
 		var scripts = [];
diff --git a/tests/js/vendor/qunit-1.19.0.css b/tests/js/vendor/qunit-1.21.0.css
similarity index 89%
rename from tests/js/vendor/qunit-1.19.0.css
rename to tests/js/vendor/qunit-1.21.0.css
index bf224b30a0..b23d647a24 100644
--- a/tests/js/vendor/qunit-1.19.0.css
+++ b/tests/js/vendor/qunit-1.21.0.css
@@ -1,27 +1,27 @@
 /*!
- * QUnit 1.19.0
- * http://qunitjs.com/
+ * QUnit 1.21.0
+ * https://qunitjs.com/
  *
  * Copyright jQuery Foundation and other contributors
  * Released under the MIT license
- * http://jquery.org/license
+ * https://jquery.org/license
  *
- * Date: 2015-09-01T15:00Z
+ * Date: 2016-02-01T13:07Z
  */
 
 /** Font Family and Sizes */
 
-#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult {
 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 }
 
-#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-testrunner-toolbar, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 #qunit-tests { font-size: smaller; }
 
 
 /** Resets */
 
-#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-filteredTest, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 	margin: 0;
 	padding: 0;
 }
@@ -68,6 +68,12 @@
 	overflow: hidden;
 }
 
+#qunit-filteredTest {
+	padding: 0.5em 1em 0.5em 1em;
+	background-color: #F4FF77;
+	color: #366097;
+}
+
 #qunit-userAgent {
 	padding: 0.5em 1em 0.5em 1em;
 	background-color: #2B81AF;
@@ -114,6 +120,10 @@
 	display: list-item;
 }
 
+#qunit-tests.hidepass {
+	position: relative;
+}
+
 #qunit-tests.hidepass li.running,
 #qunit-tests.hidepass li.pass {
 	visibility: hidden;
diff --git a/tests/js/vendor/qunit-1.19.0.js b/tests/js/vendor/qunit-1.21.0.js
similarity index 89%
rename from tests/js/vendor/qunit-1.19.0.js
rename to tests/js/vendor/qunit-1.21.0.js
index 2fbd37d7e2..2d740f1b80 100644
--- a/tests/js/vendor/qunit-1.19.0.js
+++ b/tests/js/vendor/qunit-1.21.0.js
@@ -1,12 +1,12 @@
 /*!
- * QUnit 1.19.0
- * http://qunitjs.com/
+ * QUnit 1.21.0
+ * https://qunitjs.com/
  *
  * Copyright jQuery Foundation and other contributors
  * Released under the MIT license
- * http://jquery.org/license
+ * https://jquery.org/license
  *
- * Date: 2015-09-01T15:00Z
+ * Date: 2016-02-01T13:07Z
  */
 
 (function( global ) {
@@ -128,7 +128,7 @@ function objectType( obj ) {
 	}
 
 	var match = toString.call( obj ).match( /^\[object\s(.*)\]$/ ),
-		type = match && match[ 1 ] || "";
+		type = match && match[ 1 ];
 
 	switch ( type ) {
 		case "Number":
@@ -144,12 +144,12 @@ function objectType( obj ) {
 		case "Date":
 		case "RegExp":
 		case "Function":
+		case "Symbol":
 			return type.toLowerCase();
 	}
 	if ( typeof obj === "object" ) {
 		return "object";
 	}
-	return undefined;
 }
 
 // Safe object type checking
@@ -256,6 +256,10 @@ var config = {
 	// by default, modify document.title when suite is done
 	altertitle: true,
 
+	// HTML Reporter: collapse every test except the first failing test
+	// If false, all failing tests will be expanded
+	collapse: true,
+
 	// by default, scroll to top of the page when suite is done
 	scrolltop: true,
 
@@ -290,6 +294,9 @@ var config = {
 	// Set of all modules.
 	modules: [],
 
+	// Stack of nested modules
+	moduleStack: [],
+
 	// The first unnamed module
 	currentModule: {
 		name: "",
@@ -389,7 +396,7 @@ function verifyLoggingCallbacks() {
 				global.console.warn(
 					"QUnit." + loggingCallback + " was replaced with a new value.\n" +
 					"Please, check out the documentation on how to apply logging callbacks.\n" +
-					"Reference: http://api.qunitjs.com/category/callbacks/"
+					"Reference: https://api.qunitjs.com/category/callbacks/"
 				);
 			}
 		}
@@ -440,17 +447,21 @@ QUnit.urlParams = urlParams;
 QUnit.isLocal = !( defined.document && window.location.protocol !== "file:" );
 
 // Expose the current QUnit version
-QUnit.version = "1.19.0";
+QUnit.version = "1.21.0";
 
 extend( QUnit, {
 
 	// call on start of module test to prepend name to all tests
-	module: function( name, testEnvironment ) {
-		var currentModule = {
-			name: name,
-			testEnvironment: testEnvironment,
-			tests: []
-		};
+	module: function( name, testEnvironment, executeNow ) {
+		var module, moduleFns;
+		var currentModule = config.currentModule;
+
+		if ( arguments.length === 2 ) {
+			if ( testEnvironment instanceof Function ) {
+				executeNow = testEnvironment;
+				testEnvironment = undefined;
+			}
+		}
 
 		// DEPRECATED: handles setup/teardown functions,
 		// beforeEach and afterEach should be used instead
@@ -463,8 +474,51 @@ extend( QUnit, {
 			delete testEnvironment.teardown;
 		}
 
-		config.modules.push( currentModule );
-		config.currentModule = currentModule;
+		module = createModule();
+
+		moduleFns = {
+			beforeEach: setHook( module, "beforeEach" ),
+			afterEach: setHook( module, "afterEach" )
+		};
+
+		if ( executeNow instanceof Function ) {
+			config.moduleStack.push( module );
+			setCurrentModule( module );
+			executeNow.call( module.testEnvironment, moduleFns );
+			config.moduleStack.pop();
+			module = module.parentModule || currentModule;
+		}
+
+		setCurrentModule( module );
+
+		function createModule() {
+			var parentModule = config.moduleStack.length ?
+				config.moduleStack.slice( -1 )[ 0 ] : null;
+			var moduleName = parentModule !== null ?
+				[ parentModule.name, name ].join( " > " ) : name;
+			var module = {
+				name: moduleName,
+				parentModule: parentModule,
+				tests: []
+			};
+
+			var env = {};
+			if ( parentModule ) {
+				extend( env, parentModule.testEnvironment );
+				delete env.beforeEach;
+				delete env.afterEach;
+			}
+			extend( env, testEnvironment );
+			module.testEnvironment = env;
+
+			config.modules.push( module );
+			return module;
+		}
+
+		function setCurrentModule( module ) {
+			config.currentModule = module;
+		}
+
 	},
 
 	// DEPRECATED: QUnit.asyncTest() will be removed in QUnit 2.0.
@@ -474,6 +528,8 @@ extend( QUnit, {
 
 	skip: skip,
 
+	only: only,
+
 	// DEPRECATED: The functionality of QUnit.start() will be altered in QUnit 2.0.
 	// In QUnit 2.0, invoking it will ONLY affect the `QUnit.config.autostart` blocking behavior.
 	start: function( count ) {
@@ -500,6 +556,17 @@ extend( QUnit, {
 			// If a test is running, adjust its semaphore
 			config.current.semaphore -= count || 1;
 
+			// If semaphore is non-numeric, throw error
+			if ( isNaN( config.current.semaphore ) ) {
+				config.current.semaphore = 0;
+
+				QUnit.pushFailure(
+					"Called start() with a non-numeric decrement.",
+					sourceFromStacktrace( 2 )
+				);
+				return;
+			}
+
 			// Don't start until equal number of stop-calls
 			if ( config.current.semaphore > 0 ) {
 				return;
@@ -699,6 +766,19 @@ function done() {
 	});
 }
 
+function setHook( module, hookName ) {
+	if ( module.testEnvironment === undefined ) {
+		module.testEnvironment = {};
+	}
+
+	return function( callback ) {
+		module.testEnvironment[ hookName ] = callback;
+	};
+}
+
+var focused = false;
+var priorityCount = 0;
+
 function Test( settings ) {
 	var i, l;
 
@@ -801,14 +881,12 @@ Test.prototype = {
 		this.callbackStarted = now();
 
 		if ( config.notrycatch ) {
-			promise = this.callback.call( this.testEnvironment, this.assert );
-			this.resolvePromise( promise );
+			runTest( this );
 			return;
 		}
 
 		try {
-			promise = this.callback.call( this.testEnvironment, this.assert );
-			this.resolvePromise( promise );
+			runTest( this );
 		} catch ( e ) {
 			this.pushFailure( "Died on test #" + ( this.assertions.length + 1 ) + " " +
 				this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
@@ -821,6 +899,11 @@ Test.prototype = {
 				QUnit.start();
 			}
 		}
+
+		function runTest( test ) {
+			promise = test.callback.call( test.testEnvironment, test.assert );
+			test.resolvePromise( promise );
+		}
 	},
 
 	after: function() {
@@ -833,16 +916,19 @@ Test.prototype = {
 		return function runHook() {
 			config.current = test;
 			if ( config.notrycatch ) {
-				promise = hook.call( test.testEnvironment, test.assert );
-				test.resolvePromise( promise, hookName );
+				callHook();
 				return;
 			}
 			try {
-				promise = hook.call( test.testEnvironment, test.assert );
-				test.resolvePromise( promise, hookName );
+				callHook();
 			} catch ( error ) {
 				test.pushFailure( hookName + " failed on " + test.testName + ": " +
-					( error.message || error ), extractStacktrace( error, 0 ) );
+				( error.message || error ), extractStacktrace( error, 0 ) );
+			}
+
+			function callHook() {
+				promise = hook.call( test.testEnvironment, test.assert );
+				test.resolvePromise( promise, hookName );
 			}
 		};
 	},
@@ -851,16 +937,20 @@ Test.prototype = {
 	hooks: function( handler ) {
 		var hooks = [];
 
-		// Hooks are ignored on skipped tests
-		if ( this.skip ) {
-			return hooks;
+		function processHooks( test, module ) {
+			if ( module.parentModule ) {
+				processHooks( test, module.parentModule );
+			}
+			if ( module.testEnvironment &&
+				QUnit.objectType( module.testEnvironment[ handler ] ) === "function" ) {
+				hooks.push( test.queueHook( module.testEnvironment[ handler ], handler ) );
+			}
 		}
 
-		if ( this.module.testEnvironment &&
-				QUnit.objectType( this.module.testEnvironment[ handler ] ) === "function" ) {
-			hooks.push( this.queueHook( this.module.testEnvironment[ handler ], handler ) );
+		// Hooks are ignored on skipped tests
+		if ( !this.skip ) {
+			processHooks( this, this.module );
 		}
-
 		return hooks;
 	},
 
@@ -921,7 +1011,7 @@ Test.prototype = {
 	},
 
 	queue: function() {
-		var bad,
+		var priority,
 			test = this;
 
 		if ( !this.valid() ) {
@@ -937,7 +1027,6 @@ Test.prototype = {
 				},
 
 				test.hooks( "beforeEach" ),
-
 				function() {
 					test.run();
 				},
@@ -953,16 +1042,11 @@ Test.prototype = {
 			]);
 		}
 
-		// `bad` initialized at top of scope
-		// defer when previous test run passed, if storage is available
-		bad = QUnit.config.reorder && defined.sessionStorage &&
+		// Prioritize previously failed tests, detected from sessionStorage
+		priority = QUnit.config.reorder && defined.sessionStorage &&
 				+sessionStorage.getItem( "qunit-test-" + this.module.name + "-" + this.testName );
 
-		if ( bad ) {
-			run();
-		} else {
-			synchronize( run, true );
-		}
+		return synchronize( run, priority );
 	},
 
 	push: function( result, actual, expected, message, negative ) {
@@ -1051,10 +1135,21 @@ Test.prototype = {
 	},
 
 	valid: function() {
-		var include,
-			filter = config.filter && config.filter.toLowerCase(),
+		var filter = config.filter,
+			regexFilter = /^(!?)\/([\w\W]*)\/(i?$)/.exec( filter ),
 			module = QUnit.urlParams.module && QUnit.urlParams.module.toLowerCase(),
-			fullName = ( this.module.name + ": " + this.testName ).toLowerCase();
+			fullName = ( this.module.name + ": " + this.testName );
+
+		function testInModuleChain( testModule ) {
+			var testModuleName = testModule.name ? testModule.name.toLowerCase() : null;
+			if ( testModuleName === module ) {
+				return true;
+			} else if ( testModule.parentModule ) {
+				return testInModuleChain( testModule.parentModule );
+			} else {
+				return false;
+			}
+		}
 
 		// Internally-generated tests are always valid
 		if ( this.callback && this.callback.validTest ) {
@@ -1065,7 +1160,7 @@ Test.prototype = {
 			return false;
 		}
 
-		if ( module && ( !this.module.name || this.module.name.toLowerCase() !== module ) ) {
+		if ( module && !testInModuleChain( this.module ) ) {
 			return false;
 		}
 
@@ -1073,7 +1168,23 @@ Test.prototype = {
 			return true;
 		}
 
-		include = filter.charAt( 0 ) !== "!";
+		return regexFilter ?
+			this.regexFilter( !!regexFilter[1], regexFilter[2], regexFilter[3], fullName ) :
+			this.stringFilter( filter, fullName );
+	},
+
+	regexFilter: function( exclude, pattern, flags, fullName ) {
+		var regex = new RegExp( pattern, flags );
+		var match = regex.test( fullName );
+
+		return match !== exclude;
+	},
+
+	stringFilter: function( filter, fullName ) {
+		filter = filter.toLowerCase();
+		fullName = fullName.toLowerCase();
+
+		var include = filter.charAt( 0 ) !== "!";
 		if ( !include ) {
 			filter = filter.slice( 1 );
 		}
@@ -1086,7 +1197,6 @@ Test.prototype = {
 		// Otherwise, do the opposite
 		return !include;
 	}
-
 };
 
 // Resets the test setup. Useful for tests that modify the DOM.
@@ -1147,14 +1257,21 @@ function generateHash( module, testName ) {
 	return hex.slice( -8 );
 }
 
-function synchronize( callback, last ) {
+function synchronize( callback, priority ) {
+	var last = !priority;
+
 	if ( QUnit.objectType( callback ) === "array" ) {
 		while ( callback.length ) {
 			synchronize( callback.shift() );
 		}
 		return;
 	}
-	config.queue.push( callback );
+
+	if ( priority ) {
+		config.queue.splice( priorityCount++, 0, callback );
+	} else {
+		config.queue.push( callback );
+	}
 
 	if ( config.autorun && !config.blocking ) {
 		process( last );
@@ -1208,6 +1325,8 @@ function asyncTest( testName, expected, callback ) {
 
 // Will be exposed as QUnit.test
 function test( testName, expected, callback, async ) {
+	if ( focused )  { return; }
+
 	var newTest;
 
 	if ( arguments.length === 2 ) {
@@ -1227,6 +1346,8 @@ function test( testName, expected, callback, async ) {
 
 // Will be exposed as QUnit.skip
 function skip( testName ) {
+	if ( focused )  { return; }
+
 	var test = new Test({
 		testName: testName,
 		skip: true
@@ -1235,6 +1356,30 @@ function skip( testName ) {
 	test.queue();
 }
 
+// Will be exposed as QUnit.only
+function only( testName, expected, callback, async ) {
+	var newTest;
+
+	if ( focused )  { return; }
+
+	QUnit.config.queue.length = 0;
+	focused = true;
+
+	if ( arguments.length === 2 ) {
+		callback = expected;
+		expected = null;
+	}
+
+	newTest = new Test({
+		testName: testName,
+		expected: expected,
+		async: async,
+		callback: callback
+	});
+
+	newTest.queue();
+}
+
 function Assert( testContext ) {
 	this.test = testContext;
 }
@@ -1252,25 +1397,36 @@ QUnit.assert = Assert.prototype = {
 		}
 	},
 
-	// Increment this Test's semaphore counter, then return a single-use function that
+	// Increment this Test's semaphore counter, then return a function that
 	// decrements that counter a maximum of once.
-	async: function() {
+	async: function( count ) {
 		var test = this.test,
-			popped = false;
+			popped = false,
+			acceptCallCount = count;
+
+		if ( typeof acceptCallCount === "undefined" ) {
+			acceptCallCount = 1;
+		}
 
 		test.semaphore += 1;
 		test.usedAsync = true;
 		pauseProcessing();
 
 		return function done() {
-			if ( !popped ) {
-				test.semaphore -= 1;
-				popped = true;
-				resumeProcessing();
-			} else {
-				test.pushFailure( "Called the callback returned from `assert.async` more than once",
+
+			if ( popped ) {
+				test.pushFailure( "Too many calls to the `assert.async` callback",
 					sourceFromStacktrace( 2 ) );
+				return;
+			}
+			acceptCallCount -= 1;
+			if ( acceptCallCount > 0 ) {
+				return;
 			}
+
+			test.semaphore -= 1;
+			popped = true;
+			resumeProcessing();
 		};
 	},
 
@@ -1310,7 +1466,7 @@ QUnit.assert = Assert.prototype = {
 	notOk: function( result, message ) {
 		message = message || ( !result ? "okay" : "failed, expected argument to be falsy, was: " +
 			QUnit.dump.parse( result ) );
-		this.push( !result, result, false, message, true );
+		this.push( !result, result, false, message );
 	},
 
 	equal: function( actual, expected, message ) {
@@ -1408,7 +1564,7 @@ QUnit.assert = Assert.prototype = {
 	}
 };
 
-// Provide an alternative to assert.throws(), for enviroments that consider throws a reserved word
+// Provide an alternative to assert.throws(), for environments that consider throws a reserved word
 // Known to us are: Closure Compiler, Narwhal
 (function() {
 	/*jshint sub:true */
@@ -1439,258 +1595,240 @@ function errorString( error ) {
 // Author: Philippe Rathé <prathe@gmail.com>
 QUnit.equiv = (function() {
 
-	// Call the o related callback with the given arguments.
-	function bindCallbacks( o, callbacks, args ) {
-		var prop = QUnit.objectType( o );
-		if ( prop ) {
-			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
-				return callbacks[ prop ].apply( callbacks, args );
-			} else {
-				return callbacks[ prop ]; // or undefined
-			}
-		}
-	}
+	// Stack to decide between skip/abort functions
+	var callers = [];
 
-	// the real equiv function
-	var innerEquiv,
+	// Stack to avoiding loops from circular referencing
+	var parents = [];
+	var parentsB = [];
 
-		// stack to decide between skip/abort functions
-		callers = [],
+	var getProto = Object.getPrototypeOf || function( obj ) {
 
-		// stack to avoiding loops from circular referencing
-		parents = [],
-		parentsB = [],
+		/*jshint proto: true */
+		return obj.__proto__;
+	};
 
-		getProto = Object.getPrototypeOf || function( obj ) {
-			/* jshint camelcase: false, proto: true */
-			return obj.__proto__;
-		},
-		callbacks = (function() {
+	function useStrictEquality( b, a ) {
 
-			// for string, boolean, number and null
-			function useStrictEquality( b, a ) {
+		// To catch short annotation VS 'new' annotation of a declaration. e.g.:
+		// `var i = 1;`
+		// `var j = new Number(1);`
+		if ( typeof a === "object" ) {
+			a = a.valueOf();
+		}
+		if ( typeof b === "object" ) {
+			b = b.valueOf();
+		}
 
-				/*jshint eqeqeq:false */
-				if ( b instanceof a.constructor || a instanceof b.constructor ) {
+		return a === b;
+	}
 
-					// to catch short annotation VS 'new' annotation of a
-					// declaration
-					// e.g. var i = 1;
-					// var j = new Number(1);
-					return a == b;
-				} else {
-					return a === b;
-				}
-			}
+	function compareConstructors( a, b ) {
+		var protoA = getProto( a );
+		var protoB = getProto( b );
 
-			return {
-				"string": useStrictEquality,
-				"boolean": useStrictEquality,
-				"number": useStrictEquality,
-				"null": useStrictEquality,
-				"undefined": useStrictEquality,
+		// Comparing constructors is more strict than using `instanceof`
+		if ( a.constructor === b.constructor ) {
+			return true;
+		}
 
-				"nan": function( b ) {
-					return isNaN( b );
-				},
+		// Ref #851
+		// If the obj prototype descends from a null constructor, treat it
+		// as a null prototype.
+		if ( protoA && protoA.constructor === null ) {
+			protoA = null;
+		}
+		if ( protoB && protoB.constructor === null ) {
+			protoB = null;
+		}
 
-				"date": function( b, a ) {
-					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
-				},
+		// Allow objects with no prototype to be equivalent to
+		// objects with Object as their constructor.
+		if ( ( protoA === null && protoB === Object.prototype ) ||
+				( protoB === null && protoA === Object.prototype ) ) {
+			return true;
+		}
 
-				"regexp": function( b, a ) {
-					return QUnit.objectType( b ) === "regexp" &&
+		return false;
+	}
 
-						// the regex itself
-						a.source === b.source &&
+	function getRegExpFlags( regexp ) {
+		return "flags" in regexp ? regexp.flags : regexp.toString().match( /[gimuy]*$/ )[ 0 ];
+	}
 
-						// and its modifiers
-						a.global === b.global &&
+	var callbacks = {
+		"string": useStrictEquality,
+		"boolean": useStrictEquality,
+		"number": useStrictEquality,
+		"null": useStrictEquality,
+		"undefined": useStrictEquality,
+		"symbol": useStrictEquality,
+		"date": useStrictEquality,
 
-						// (gmi) ...
-						a.ignoreCase === b.ignoreCase &&
-						a.multiline === b.multiline &&
-						a.sticky === b.sticky;
-				},
+		"nan": function() {
+			return true;
+		},
 
-				// - skip when the property is a method of an instance (OOP)
-				// - abort otherwise,
-				// initial === would have catch identical references anyway
-				"function": function() {
-					var caller = callers[ callers.length - 1 ];
-					return caller !== Object && typeof caller !== "undefined";
-				},
+		"regexp": function( b, a ) {
+			return a.source === b.source &&
 
-				"array": function( b, a ) {
-					var i, j, len, loop, aCircular, bCircular;
+				// Include flags in the comparison
+				getRegExpFlags( a ) === getRegExpFlags( b );
+		},
 
-					// b could be an object literal here
-					if ( QUnit.objectType( b ) !== "array" ) {
-						return false;
-					}
+		// - skip when the property is a method of an instance (OOP)
+		// - abort otherwise,
+		// initial === would have catch identical references anyway
+		"function": function() {
+			var caller = callers[ callers.length - 1 ];
+			return caller !== Object && typeof caller !== "undefined";
+		},
 
-					len = a.length;
-					if ( len !== b.length ) {
-						// safe and faster
-						return false;
-					}
+		"array": function( b, a ) {
+			var i, j, len, loop, aCircular, bCircular;
 
-					// track reference to avoid circular references
-					parents.push( a );
-					parentsB.push( b );
-					for ( i = 0; i < len; i++ ) {
-						loop = false;
-						for ( j = 0; j < parents.length; j++ ) {
-							aCircular = parents[ j ] === a[ i ];
-							bCircular = parentsB[ j ] === b[ i ];
-							if ( aCircular || bCircular ) {
-								if ( a[ i ] === b[ i ] || aCircular && bCircular ) {
-									loop = true;
-								} else {
-									parents.pop();
-									parentsB.pop();
-									return false;
-								}
-							}
-						}
-						if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
+			len = a.length;
+			if ( len !== b.length ) {
+				// safe and faster
+				return false;
+			}
+
+			// Track reference to avoid circular references
+			parents.push( a );
+			parentsB.push( b );
+			for ( i = 0; i < len; i++ ) {
+				loop = false;
+				for ( j = 0; j < parents.length; j++ ) {
+					aCircular = parents[ j ] === a[ i ];
+					bCircular = parentsB[ j ] === b[ i ];
+					if ( aCircular || bCircular ) {
+						if ( a[ i ] === b[ i ] || aCircular && bCircular ) {
+							loop = true;
+						} else {
 							parents.pop();
 							parentsB.pop();
 							return false;
 						}
 					}
+				}
+				if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
 					parents.pop();
 					parentsB.pop();
-					return true;
-				},
-
-				"set": function( b, a ) {
-					var aArray, bArray;
-
-					// b could be any object here
-					if ( QUnit.objectType( b ) !== "set" ) {
-						return false;
-					}
-
-					aArray = [];
-					a.forEach( function( v ) {
-						aArray.push( v );
-					});
-					bArray = [];
-					b.forEach( function( v ) {
-						bArray.push( v );
-					});
+					return false;
+				}
+			}
+			parents.pop();
+			parentsB.pop();
+			return true;
+		},
 
-					return innerEquiv( bArray, aArray );
-				},
+		"set": function( b, a ) {
+			var aArray, bArray;
 
-				"map": function( b, a ) {
-					var aArray, bArray;
+			aArray = [];
+			a.forEach( function( v ) {
+				aArray.push( v );
+			});
+			bArray = [];
+			b.forEach( function( v ) {
+				bArray.push( v );
+			});
 
-					// b could be any object here
-					if ( QUnit.objectType( b ) !== "map" ) {
-						return false;
-					}
+			return innerEquiv( bArray, aArray );
+		},
 
-					aArray = [];
-					a.forEach( function( v, k ) {
-						aArray.push( [ k, v ] );
-					});
-					bArray = [];
-					b.forEach( function( v, k ) {
-						bArray.push( [ k, v ] );
-					});
+		"map": function( b, a ) {
+			var aArray, bArray;
 
-					return innerEquiv( bArray, aArray );
-				},
+			aArray = [];
+			a.forEach( function( v, k ) {
+				aArray.push( [ k, v ] );
+			});
+			bArray = [];
+			b.forEach( function( v, k ) {
+				bArray.push( [ k, v ] );
+			});
 
-				"object": function( b, a ) {
+			return innerEquiv( bArray, aArray );
+		},
 
-					/*jshint forin:false */
-					var i, j, loop, aCircular, bCircular,
-						// Default to true
-						eq = true,
-						aProperties = [],
-						bProperties = [];
+		"object": function( b, a ) {
+			var i, j, loop, aCircular, bCircular;
 
-					// comparing constructors is more strict than using
-					// instanceof
-					if ( a.constructor !== b.constructor ) {
+			// Default to true
+			var eq = true;
+			var aProperties = [];
+			var bProperties = [];
 
-						// Allow objects with no prototype to be equivalent to
-						// objects with Object as their constructor.
-						if ( !( ( getProto( a ) === null && getProto( b ) === Object.prototype ) ||
-							( getProto( b ) === null && getProto( a ) === Object.prototype ) ) ) {
-							return false;
-						}
-					}
+			if ( compareConstructors( a, b ) === false ) {
+				return false;
+			}
 
-					// stack constructor before traversing properties
-					callers.push( a.constructor );
-
-					// track reference to avoid circular references
-					parents.push( a );
-					parentsB.push( b );
-
-					// be strict: don't ensure hasOwnProperty and go deep
-					for ( i in a ) {
-						loop = false;
-						for ( j = 0; j < parents.length; j++ ) {
-							aCircular = parents[ j ] === a[ i ];
-							bCircular = parentsB[ j ] === b[ i ];
-							if ( aCircular || bCircular ) {
-								if ( a[ i ] === b[ i ] || aCircular && bCircular ) {
-									loop = true;
-								} else {
-									eq = false;
-									break;
-								}
-							}
-						}
-						aProperties.push( i );
-						if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
+			// Stack constructor before traversing properties
+			callers.push( a.constructor );
+
+			// Track reference to avoid circular references
+			parents.push( a );
+			parentsB.push( b );
+
+			// Be strict: don't ensure hasOwnProperty and go deep
+			for ( i in a ) {
+				loop = false;
+				for ( j = 0; j < parents.length; j++ ) {
+					aCircular = parents[ j ] === a[ i ];
+					bCircular = parentsB[ j ] === b[ i ];
+					if ( aCircular || bCircular ) {
+						if ( a[ i ] === b[ i ] || aCircular && bCircular ) {
+							loop = true;
+						} else {
 							eq = false;
 							break;
 						}
 					}
+				}
+				aProperties.push( i );
+				if ( !loop && !innerEquiv( a[ i ], b[ i ] ) ) {
+					eq = false;
+					break;
+				}
+			}
 
-					parents.pop();
-					parentsB.pop();
-					callers.pop(); // unstack, we are done
+			parents.pop();
+			parentsB.pop();
 
-					for ( i in b ) {
-						bProperties.push( i ); // collect b's properties
-					}
+			// Unstack, we are done
+			callers.pop();
 
-					// Ensures identical properties name
-					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
-				}
-			};
-		}());
+			for ( i in b ) {
+
+				// Collect b's properties
+				bProperties.push( i );
+			}
 
-	innerEquiv = function() { // can take multiple arguments
-		var args = [].slice.apply( arguments );
-		if ( args.length < 2 ) {
-			return true; // end transition
+			// Ensures identical properties name
+			return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
 		}
+	};
 
-		return ( (function( a, b ) {
-			if ( a === b ) {
-				return true; // catch the most you can
-			} else if ( a === null || b === null || typeof a === "undefined" ||
-					typeof b === "undefined" ||
-					QUnit.objectType( a ) !== QUnit.objectType( b ) ) {
+	function typeEquiv( a, b ) {
+		var type = QUnit.objectType( a );
+		return QUnit.objectType( b ) === type && callbacks[ type ]( b, a );
+	}
 
-				// don't lose time with error prone cases
-				return false;
-			} else {
-				return bindCallbacks( a, callbacks, [ b, a ] );
-			}
+	// The real equiv function
+	function innerEquiv( a, b ) {
 
-			// apply transition with (1..n) arguments
-		}( args[ 0 ], args[ 1 ] ) ) &&
-			innerEquiv.apply( this, args.splice( 1, args.length - 1 ) ) );
-	};
+		// We're done when there's nothing more to compare
+		if ( arguments.length < 2 ) {
+			return true;
+		}
+
+		// Require type-specific equality
+		return ( a === b || typeEquiv( a, b ) ) &&
+
+			// ...across all consecutive argument pairs
+			( arguments.length === 2 || innerEquiv.apply( this, [].slice.call( arguments, 1 ) ) );
+	}
 
 	return innerEquiv;
 }());
@@ -1937,7 +2075,7 @@ QUnit.dump = (function() {
 				key: quote,
 				// function calls it internally, it's the content of the function
 				functionCode: "[code]",
-				// node calls it internally, it's an html attribute value
+				// node calls it internally, it's a html attribute value
 				attribute: quote,
 				string: quote,
 				date: quote,
@@ -1999,7 +2137,8 @@ if ( defined.document ) {
 				"notDeepEqual",
 				"strictEqual",
 				"notStrictEqual",
-				"throws"
+				"throws",
+				"raises"
 			];
 
 		for ( i = 0, l = keys.length; i < l; i++ ) {
@@ -2038,13 +2177,13 @@ if ( typeof define === "function" && define.amd ) {
  * The original source of google-diff-match-patch is attributable and licensed as follows:
  *
  * Copyright 2006 Google Inc.
- * http://code.google.com/p/google-diff-match-patch/
+ * https://code.google.com/p/google-diff-match-patch/
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -2271,7 +2410,7 @@ QUnit.diff = ( function() {
 			return 0;
 		}
 		// Binary search.
-		// Performance analysis: http://neil.fraser.name/news/2007/10/09/
+		// Performance analysis: https://neil.fraser.name/news/2007/10/09/
 		pointermin = 0;
 		pointermax = Math.min( text1.length, text2.length );
 		pointermid = pointermax;
@@ -2304,7 +2443,7 @@ QUnit.diff = ( function() {
 			return 0;
 		}
 		// Binary search.
-		// Performance analysis: http://neil.fraser.name/news/2007/10/09/
+		// Performance analysis: https://neil.fraser.name/news/2007/10/09/
 		pointermin = 0;
 		pointermax = Math.min( text1.length, text2.length );
 		pointermid = pointermax;
@@ -2886,7 +3025,7 @@ QUnit.diff = ( function() {
 
 		// Start by looking for a single character match
 		// and increase length until no match is found.
-		// Performance analysis: http://neil.fraser.name/news/2010/11/04/
+		// Performance analysis: https://neil.fraser.name/news/2010/11/04/
 		best = 0;
 		length = 1;
 		while ( true ) {
@@ -3021,7 +3160,7 @@ QUnit.diff = ( function() {
 				// Upon reaching an equality, check for prior redundancies.
 				if ( countDelete + countInsert > 1 ) {
 					if ( countDelete !== 0 && countInsert !== 0 ) {
-						// Factor out any common prefixies.
+						// Factor out any common prefixes.
 						commonlength = this.diffCommonPrefix( textInsert, textDelete );
 						if ( commonlength !== 0 ) {
 							if ( ( pointer - countDelete - countInsert ) > 0 &&
@@ -3212,6 +3351,7 @@ QUnit.init = function() {
 };
 
 var config = QUnit.config,
+	collapseNext = false,
 	hasOwn = Object.prototype.hasOwnProperty,
 	defined = {
 		document: window.document !== undefined,
@@ -3608,6 +3748,17 @@ function storeFixture() {
 	}
 }
 
+function appendFilteredTest() {
+	var testId = QUnit.config.testId;
+	if ( !testId || testId.length <= 0 ) {
+		return "";
+	}
+	return "<div id='qunit-filteredTest'>Rerunning selected tests: " + testId.join(", ") +
+		" <a id='qunit-clearFilter' href='" +
+		setUrl({ filter: undefined, module: undefined, testId: undefined }) +
+		"'>" + "Run all tests" + "</a></div>";
+}
+
 function appendUserAgent() {
 	var userAgent = id( "qunit-userAgent" );
 
@@ -3615,7 +3766,7 @@ function appendUserAgent() {
 		userAgent.innerHTML = "";
 		userAgent.appendChild(
 			document.createTextNode(
-				"QUnit " + QUnit.version  + "; " + navigator.userAgent
+				"QUnit " + QUnit.version + "; " + navigator.userAgent
 			)
 		);
 	}
@@ -3679,6 +3830,7 @@ QUnit.begin(function( details ) {
 			"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
 			"<h2 id='qunit-banner'></h2>" +
 			"<div id='qunit-testrunner-toolbar'></div>" +
+			appendFilteredTest() +
 			"<h2 id='qunit-userAgent'></h2>" +
 			"<ol id='qunit-tests'></ol>";
 	}
@@ -3853,7 +4005,7 @@ QUnit.log(function( details ) {
 
 		message += "</table>";
 
-	// this occours when pushFailure is set and we have an extracted stack trace
+	// this occurs when pushFailure is set and we have an extracted stack trace
 	} else if ( !details.result && details.source ) {
 		message += "<table>" +
 			"<tr class='test-source'><th>Source: </th><td><pre>" +
@@ -3895,6 +4047,16 @@ QUnit.testDone(function( details ) {
 	}
 
 	if ( bad === 0 ) {
+
+		// Collapse the passing tests
+		addClass( assertList, "qunit-collapsed" );
+	} else if ( bad && config.collapse && !collapseNext ) {
+
+		// Skip collapsing the first failing test
+		collapseNext = true;
+	} else {
+
+		// Collapse remaining tests
 		addClass( assertList, "qunit-collapsed" );
 	}