Update to MediaWiki 1.20.2

this update includes:
* adjusted Arch Linux skin
* updated FluxBBAuthPlugin
* patch for https://bugzilla.wikimedia.org/show_bug.cgi?id=44024

25 files changed, 2450 insertions, 927 deletions

diff --git a/tests/qunit/suites/resources/jquery/jquery.autoEllipsis.test.js b/tests/qunit/suites/resources/jquery/jquery.autoEllipsis.test.js
index 6e371384..0dee2ef0 100644
--- a/tests/qunit/suites/resources/jquery/jquery.autoEllipsis.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.autoEllipsis.test.js
@@ -1,9 +1,6 @@
-module( 'jquery.autoEllipsis', QUnit.newMwEnvironment() );
+( function ( mw, $ ) {
 
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.fn.autoEllipsis, 'jQuery.fn.autoEllipsis defined' );
-});
+QUnit.module( 'jquery.autoEllipsis', QUnit.newMwEnvironment() );
 
 function createWrappedDiv( text, width ) {
 	var $wrapper = $( '<div>' ).css( 'width', width );
@@ -14,15 +11,13 @@ function createWrappedDiv( text, width ) {
 
 function findDivergenceIndex( a, b ) {
 	var i = 0;
-	while ( i < a.length && i < b.length && a[i] == b[i] ) {
+	while ( i < a.length && i < b.length && a[i] === b[i] ) {
 		i++;
 	}
 	return i;
 }
 
-test( 'Position right', function() {
-	expect(4);
-
+QUnit.test( 'Position right', 4, function ( assert ) {
 	// We need this thing to be visible, so append it to the DOM
 	var origText = 'This is a really long random string and there is no way it fits in 100 pixels.';
 	var $wrapper = createWrappedDiv( origText, '100px' );
@@ -31,25 +26,27 @@ test( 'Position right', function() {
 
 	// Verify that, and only one, span element was created
 	var $span = $wrapper.find( '> span' );
-	strictEqual( $span.length, 1, 'autoEllipsis wrapped the contents in a span element' );
+	assert.strictEqual( $span.length, 1, 'autoEllipsis wrapped the contents in a span element' );
 
 	// Check that the text fits by turning on word wrapping
 	$span.css( 'whiteSpace', 'nowrap' );
-	ltOrEq( $span.width(), $span.parent().width(), "Text fits (making the span 'white-space:nowrap' does not make it wider than its parent)" );
+	assert.ltOrEq( $span.width(), $span.parent().width(), "Text fits (making the span 'white-space:nowrap' does not make it wider than its parent)" );
 
 	// Add two characters using scary black magic
 	var spanText = $span.text();
 	var d = findDivergenceIndex( origText, spanText );
 	var spanTextNew = spanText.substr( 0, d ) + origText[d] + origText[d] + '...';
 
-	gt( spanTextNew.length, spanText.length, 'Verify that the new span-length is indeed greater' );
+	assert.gt( spanTextNew.length, spanText.length, 'Verify that the new span-length is indeed greater' );
 
 	// Put this text in the span and verify it doesn't fit
 	$span.text( spanTextNew );
 	// In IE6 width works like min-width, allow IE6's width to be "equal to"
 	if ( $.browser.msie && Number( $.browser.version ) === 6 ) {
-		gtOrEq( $span.width(), $span.parent().width(), 'Fit is maximal (adding two characters makes it not fit any more) - IE6: Maybe equal to as well due to width behaving like min-width in IE6' );
+		assert.gtOrEq( $span.width(), $span.parent().width(), 'Fit is maximal (adding two characters makes it not fit any more) - IE6: Maybe equal to as well due to width behaving like min-width in IE6' );
 	} else {
-		gt( $span.width(), $span.parent().width(), 'Fit is maximal (adding two characters makes it not fit any more)' );
+		assert.gt( $span.width(), $span.parent().width(), 'Fit is maximal (adding two characters makes it not fit any more)' );
 	}
 });
+
+}( mediaWiki, jQuery ) );
diff --git a/tests/qunit/suites/resources/jquery/jquery.byteLength.test.js b/tests/qunit/suites/resources/jquery/jquery.byteLength.test.js
index 15fac691..a6ddfca6 100644
--- a/tests/qunit/suites/resources/jquery/jquery.byteLength.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.byteLength.test.js
@@ -1,32 +1,23 @@
-module( 'jquery.byteLength', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.byteLength, 'jQuery.byteLength defined' );
-} );
-
-test( 'Simple text', function() {
-	expect(5);
+QUnit.module( 'jquery.byteLength', QUnit.newMwEnvironment() );
 
+QUnit.test( 'Simple text', 5, function ( assert ) {
 	var	azLc = 'abcdefghijklmnopqrstuvwxyz',
 		azUc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
 		num = '0123456789',
 		x = '*',
 		space = '   ';
 
-	equal( $.byteLength( azLc ), 26, 'Lowercase a-z' );
-	equal( $.byteLength( azUc ), 26, 'Uppercase A-Z' );
-	equal( $.byteLength( num ), 10, 'Numbers 0-9' );
-	equal( $.byteLength( x ), 1, 'An asterisk' );
-	equal( $.byteLength( space ), 3, '3 spaces' );
+	assert.equal( $.byteLength( azLc ), 26, 'Lowercase a-z' );
+	assert.equal( $.byteLength( azUc ), 26, 'Uppercase A-Z' );
+	assert.equal( $.byteLength( num ), 10, 'Numbers 0-9' );
+	assert.equal( $.byteLength( x ), 1, 'An asterisk' );
+	assert.equal( $.byteLength( space ), 3, '3 spaces' );
 
 } );
 
-test( 'Special text', window.foo = function() {
-	expect(5);
-
+QUnit.test( 'Special text', 5, function ( assert ) {
 	// http://en.wikipedia.org/wiki/UTF-8
-	var	U_0024 = '\u0024',
+	var	U_0024 = '$',
 		U_00A2 = '\u00A2',
 		U_20AC = '\u20AC',
 		U_024B62 = '\u024B62',
@@ -34,9 +25,9 @@ test( 'Special text', window.foo = function() {
 		// according to http://www.fileformat.info/info/unicode/char/24B62/index.htm
 		U_024B62_alt = '\uD852\uDF62';
 
-	strictEqual( $.byteLength( U_0024 ), 1, 'U+0024: 1 byte. \u0024 (dollar sign)' );
-	strictEqual( $.byteLength( U_00A2 ), 2, 'U+00A2: 2 bytes. \u00A2 (cent sign)' );
-	strictEqual( $.byteLength( U_20AC ), 3, 'U+20AC: 3 bytes. \u20AC (euro sign)' );
-	strictEqual( $.byteLength( U_024B62 ), 4, 'U+024B62: 4 bytes. \uD852\uDF62 (a Han character)' );
-	strictEqual( $.byteLength( U_024B62_alt ), 4, 'U+024B62: 4 bytes. \uD852\uDF62 (a Han character) - alternative method' );
+	assert.strictEqual( $.byteLength( U_0024 ), 1, 'U+0024: 1 byte. $ (dollar sign)' );
+	assert.strictEqual( $.byteLength( U_00A2 ), 2, 'U+00A2: 2 bytes. \u00A2 (cent sign)' );
+	assert.strictEqual( $.byteLength( U_20AC ), 3, 'U+20AC: 3 bytes. \u20AC (euro sign)' );
+	assert.strictEqual( $.byteLength( U_024B62 ), 4, 'U+024B62: 4 bytes. \uD852\uDF62 (a Han character)' );
+	assert.strictEqual( $.byteLength( U_024B62_alt ), 4, 'U+024B62: 4 bytes. \uD852\uDF62 (a Han character) - alternative method' );
 } );
diff --git a/tests/qunit/suites/resources/jquery/jquery.byteLimit.test.js b/tests/qunit/suites/resources/jquery/jquery.byteLimit.test.js
index 3346c2d5..4f86eb96 100644
--- a/tests/qunit/suites/resources/jquery/jquery.byteLimit.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.byteLimit.test.js
@@ -1,187 +1,234 @@
-( function () {
-
-module( 'jquery.byteLimit', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.fn.byteLimit, 'jQuery.fn.byteLimit defined' );
-} );
-
-// Basic sendkey-implementation
-$.addChars = function( $input, charstr ) {
-	var len = charstr.length;
-	for ( var i = 0; i < len; i++ ) {
-		// Keep track of the previous value
-		var prevVal = $input.val();
-
-		// Get the key code
-		var code = charstr.charCodeAt(i);
-
-		// Trigger event and undo if prevented
-		var event = new jQuery.Event( 'keypress', { keyCode: code, which: code, charCode: code } );
-		$input.trigger( event );
-		if ( !event.isDefaultPrevented() ) {
-			$input.val( prevVal + charstr.charAt(i) );
-		}
-	}
-};
-
-/**
- * Test factory for $.fn.byteLimit
- *
- * @param $input {jQuery} jQuery object in an input element
- * @param hasLimit {Boolean} Wether a limit should apply at all
- * @param limit {Number} Limit (if used) otherwise undefined
- * The limit should be less than 20 (the sample data's length)
- */
-var byteLimitTest = function( options ) {
-	var opt = $.extend({
-		description: '',
-		$input: null,
-		sample: '',
-		hasLimit: false,
-		expected: '',
-		limit: null
-	}, options);
-
-	test( opt.description, function() {
-
-		opt.$input.appendTo( '#qunit-fixture' );
-
-		// Simulate pressing keys for each of the sample characters
-		$.addChars( opt.$input, opt.sample );
-		var	rawVal = opt.$input.val(),
-			fn = opt.$input.data( 'byteLimit-callback' ),
-			newVal = $.isFunction( fn ) ? fn( rawVal ) : rawVal;
-
-		if ( opt.hasLimit ) {
-			expect(3);
-
-			ltOrEq( $.byteLength( newVal ), opt.limit, 'Prevent keypresses after byteLimit was reached, length never exceeded the limit' );
-			equal( $.byteLength( rawVal ), $.byteLength( opt.expected ), 'Not preventing keypresses too early, length has reached the expected length' );
-			equal( rawVal, opt.expected, 'New value matches the expected string' );
+( function ( $, mw ) {
+	var simpleSample, U_20AC, mbSample;
 
-		} else {
-			expect(2);
-			equal( newVal, opt.expected, 'New value matches the expected string' );
-			equal( $.byteLength( newVal ), $.byteLength( opt.expected ), 'Unlimited scenarios are not affected, expected length reached' );
-		}
-	} );
-};
+	QUnit.module( 'jquery.byteLimit', QUnit.newMwEnvironment() );
 
-var
 	// Simple sample (20 chars, 20 bytes)
-	simpleSample = '12345678901234567890',
+	simpleSample = '12345678901234567890';
 
 	// 3 bytes (euro-symbol)
-	U_20AC = '\u20AC',
+	U_20AC = '\u20AC';
 
 	// Multi-byte sample (22 chars, 26 bytes)
 	mbSample = '1234567890' + U_20AC + '1234567890' + U_20AC;
 
-byteLimitTest({
-	description: 'Plain text input',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' ),
-	sample: simpleSample,
-	hasLimit: false,
-	expected: simpleSample
-});
-
-byteLimitTest({
-	description: 'Limit using the maxlength attribute',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.prop( 'maxLength', '10' )
-		.byteLimit(),
-	sample: simpleSample,
-	hasLimit: true,
-	limit: 10,
-	expected: '1234567890'
-});
-
-byteLimitTest({
-	description: 'Limit using a custom value',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.byteLimit( 10 ),
-	sample: simpleSample,
-	hasLimit: true,
-	limit: 10,
-	expected: '1234567890'
-});
-
-byteLimitTest({
-	description: 'Limit using a custom value, overriding maxlength attribute',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.prop( 'maxLength', '10' )
-		.byteLimit( 15 ),
-	sample: simpleSample,
-	hasLimit: true,
-	limit: 15,
-	expected: '123456789012345'
-});
-
-byteLimitTest({
-	description: 'Limit using a custom value (multibyte)',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.byteLimit( 14 ),
-	sample: mbSample,
-	hasLimit: true,
-	limit: 14,
-	expected: '1234567890' + U_20AC + '1'
-});
-
-byteLimitTest({
-	description: 'Limit using a custom value (multibyte) overlapping a byte',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.byteLimit( 12 ),
-	sample: mbSample,
-	hasLimit: true,
-	limit: 12,
-	expected: '1234567890' + '12'
-});
-
-byteLimitTest({
-	description: 'Pass the limit and a callback as input filter',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.byteLimit( 6, function( val ) {
-			// Invalid title
-			if ( val == '' ) {
-				return '';
-			}
+	// Basic sendkey-implementation
+	function addChars( $input, charstr ) {
+		var c, len;
+		for ( c = 0, len = charstr.length; c < len; c += 1 ) {
+			$input
+				.val( function ( i, val ) {
+					// Add character to the value
+					return val + charstr.charAt( c );
+				} )
+				.trigger( 'change' );
+		}
+	}
 
-			// Return without namespace prefix
-			return new mw.Title( '' + val ).getMain();
-		} ),
-	sample: 'User:Sample',
-	hasLimit: true,
-	limit: 6, // 'Sample' length
-	expected: 'User:Sample'
-});
-
-byteLimitTest({
-	description: 'Limit using the maxlength attribute and pass a callback as input filter',
-	$input: $( '<input>' )
-		.attr( 'type', 'text' )
-		.prop( 'maxLength', '6' )
-		.byteLimit( function( val ) {
-			// Invalid title
-			if ( val === '' ) {
-				return '';
+	/**
+	 * Test factory for $.fn.byteLimit
+	 *
+	 * @param $input {jQuery} jQuery object in an input element
+	 * @param hasLimit {Boolean} Wether a limit should apply at all
+	 * @param limit {Number} Limit (if used) otherwise undefined
+	 * The limit should be less than 20 (the sample data's length)
+	 */
+	function byteLimitTest( options ) {
+		var opt = $.extend({
+			description: '',
+			$input: null,
+			sample: '',
+			hasLimit: false,
+			expected: '',
+			limit: null
+		}, options);
+
+		QUnit.asyncTest( opt.description, opt.hasLimit ? 3 : 2, function ( assert ) {
+		setTimeout( function () {
+			var rawVal, fn, effectiveVal;
+
+			opt.$input.appendTo( '#qunit-fixture' );
+
+			// Simulate pressing keys for each of the sample characters
+			addChars( opt.$input, opt.sample );
+
+			rawVal = opt.$input.val();
+			fn = opt.$input.data( 'byteLimit.callback' );
+			effectiveVal = fn ? fn( rawVal ) : rawVal;
+
+			if ( opt.hasLimit ) {
+				assert.ltOrEq(
+					$.byteLength( effectiveVal ),
+					opt.limit,
+					'Prevent keypresses after byteLimit was reached, length never exceeded the limit'
+				);
+				assert.equal(
+					$.byteLength( rawVal ),
+					$.byteLength( opt.expected ),
+					'Not preventing keypresses too early, length has reached the expected length'
+				);
+				assert.equal( rawVal, opt.expected, 'New value matches the expected string' );
+
+			} else {
+				assert.equal(
+					$.byteLength( effectiveVal ),
+					$.byteLength( opt.expected ),
+					'Unlimited scenarios are not affected, expected length reached'
+				);
+				assert.equal( rawVal, opt.expected, 'New value matches the expected string' );
 			}
+			QUnit.start();
+		}, 10 );
+		} );
+	}
 
-			// Return without namespace prefix
-			return new mw.Title( '' + val ).getMain();
-		} ),
-	sample: 'User:Sample',
-	hasLimit: true,
-	limit: 6, // 'Sample' length
-	expected: 'User:Sample'
-});
-
-}() );
\ No newline at end of file
+	byteLimitTest({
+		description: 'Plain text input',
+		$input: $( '<input type="text"/>' ),
+		sample: simpleSample,
+		hasLimit: false,
+		expected: simpleSample
+	});
+
+	byteLimitTest({
+		description: 'Plain text input. Calling byteLimit with no parameters and no maxlength attribute (bug 36310)',
+		$input: $( '<input type="text"/>' )
+			.byteLimit(),
+		sample: simpleSample,
+		hasLimit: false,
+		expected: simpleSample
+	});
+
+	byteLimitTest({
+		description: 'Limit using the maxlength attribute',
+		$input: $( '<input type="text"/>' )
+			.attr( 'maxlength', '10' )
+			.byteLimit(),
+		sample: simpleSample,
+		hasLimit: true,
+		limit: 10,
+		expected: '1234567890'
+	});
+
+	byteLimitTest({
+		description: 'Limit using a custom value',
+		$input: $( '<input type="text"/>' )
+			.byteLimit( 10 ),
+		sample: simpleSample,
+		hasLimit: true,
+		limit: 10,
+		expected: '1234567890'
+	});
+
+	byteLimitTest({
+		description: 'Limit using a custom value, overriding maxlength attribute',
+		$input: $( '<input type="text"/>' )
+			.attr( 'maxlength', '10' )
+			.byteLimit( 15 ),
+		sample: simpleSample,
+		hasLimit: true,
+		limit: 15,
+		expected: '123456789012345'
+	});
+
+	byteLimitTest({
+		description: 'Limit using a custom value (multibyte)',
+		$input: $( '<input type="text"/>' )
+			.byteLimit( 14 ),
+		sample: mbSample,
+		hasLimit: true,
+		limit: 14,
+		expected: '1234567890' + U_20AC + '1'
+	});
+
+	byteLimitTest({
+		description: 'Limit using a custom value (multibyte) overlapping a byte',
+		$input: $( '<input type="text"/>' )
+			.byteLimit( 12 ),
+		sample: mbSample,
+		hasLimit: true,
+		limit: 12,
+		expected: '1234567890' + '12'
+	});
+
+	byteLimitTest({
+		description: 'Pass the limit and a callback as input filter',
+		$input: $( '<input type="text"/>' )
+			.byteLimit( 6, function ( val ) {
+				// Invalid title
+				if ( val === '' ) {
+					return '';
+				}
+
+				// Return without namespace prefix
+				return new mw.Title( String( val ) ).getMain();
+			} ),
+		sample: 'User:Sample',
+		hasLimit: true,
+		limit: 6, // 'Sample' length
+		expected: 'User:Sample'
+	});
+
+	byteLimitTest({
+		description: 'Limit using the maxlength attribute and pass a callback as input filter',
+		$input: $( '<input type="text"/>' )
+			.attr( 'maxlength', '6' )
+			.byteLimit( function ( val ) {
+				// Invalid title
+				if ( val === '' ) {
+					return '';
+				}
+
+				// Return without namespace prefix
+				return new mw.Title( String( val ) ).getMain();
+			} ),
+		sample: 'User:Sample',
+		hasLimit: true,
+		limit: 6, // 'Sample' length
+		expected: 'User:Sample'
+	});
+
+	QUnit.test( 'Confirm properties and attributes set', 4, function ( assert ) {
+		var $el, $elA, $elB;
+
+		$el = $( '<input type="text"/>' )
+			.attr( 'maxlength', '7' )
+			.appendTo( '#qunit-fixture' )
+			.byteLimit();
+
+		assert.strictEqual( $el.attr( 'maxlength' ), '7', 'maxlength attribute unchanged for simple limit' );
+
+		$el = $( '<input type="text"/>' )
+			.attr( 'maxlength', '7' )
+			.appendTo( '#qunit-fixture' )
+			.byteLimit( 12 );
+
+		assert.strictEqual( $el.attr( 'maxlength' ), '12', 'maxlength attribute updated for custom limit' );
+
+		$el = $( '<input type="text"/>' )
+			.attr( 'maxlength', '7' )
+			.appendTo( '#qunit-fixture' )
+			.byteLimit( 12, function ( val ) {
+				return val;
+			} );
+
+		assert.strictEqual( $el.attr( 'maxlength' ), undefined, 'maxlength attribute removed for limit with callback' );
+
+		$elA = $( '<input type="text"/>' )
+			.addClass( 'mw-test-byteLimit-foo' )
+			.attr( 'maxlength', '7' )
+			.appendTo( '#qunit-fixture' );
+
+		$elB = $( '<input type="text"/>' )
+			.addClass( 'mw-test-byteLimit-foo' )
+			.attr( 'maxlength', '12' )
+			.appendTo( '#qunit-fixture' );
+
+		$el = $( '.mw-test-byteLimit-foo' );
+
+		assert.strictEqual( $el.length, 2, 'Verify that there are no other elements clashing with this test suite' );
+
+		$el.byteLimit();
+	});
+
+}( jQuery, mediaWiki ) );
diff --git a/tests/qunit/suites/resources/jquery/jquery.client.test.js b/tests/qunit/suites/resources/jquery/jquery.client.test.js
index 7be41971..bf62b39a 100644
--- a/tests/qunit/suites/resources/jquery/jquery.client.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.client.test.js
@@ -1,14 +1,9 @@
-module( 'jquery.client', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( jQuery.client, 'jQuery.client defined' );
-});
+QUnit.module( 'jquery.client', QUnit.newMwEnvironment() );
 
 /** Number of user-agent defined */
 var uacount = 0;
 
-var uas = (function() {
+var uas = (function () {
 
 	// Object keyed by userAgent. Value is an array (human-readable name, client-profile object, navigator.platform value)
 	// Info based on results from http://toolserver.org/~krinkle/testswarm/job/174/
@@ -205,42 +200,59 @@ var uas = (function() {
 				ltr: true,
 				rtl: true
 			}
+		},
+		// Bug #34924
+		'Mozilla/5.0 (X11; Linux i686) AppleWebKit/534.34 (KHTML, like Gecko) rekonq Safari/534.34': {
+			title: 'Rekonq',
+			platform: 'Linux i686',
+			profile: {
+				"name": "rekonq",
+				"layout": "webkit",
+				"layoutVersion": 534,
+				"platform": "linux",
+				"version": "534.34",
+				"versionBase": "534",
+				"versionNumber": 534.34
+			},
+			wikiEditor: {
+				ltr: true,
+				rtl: true
+			}
 		}
 	};
-	$.each( uas, function() { uacount++ });
+	$.each( uas, function () {
+		uacount++;
+	});
 	return uas;
-})();
-
-test( 'profile userAgent support', function() {
-	expect(uacount);
+}());
 
+QUnit.test( 'profile userAgent support', uacount, function ( assert ) {
 	// Generate a client profile object and compare recursively
 	var uaTest = function( rawUserAgent, data ) {
 		var ret = $.client.profile( {
 			userAgent: rawUserAgent,
 			platform: data.platform
 		} );
-		deepEqual( ret, data.profile, 'Client profile support check for ' + data.title + ' (' + data.platform + '): ' + rawUserAgent );
+		assert.deepEqual( ret, data.profile, 'Client profile support check for ' + data.title + ' (' + data.platform + '): ' + rawUserAgent );
 	};
 
 	// Loop through and run tests
 	$.each( uas, uaTest );
 } );
 
-test( 'profile return validation for current user agent', function() {
-	expect(7);
+QUnit.test( 'profile return validation for current user agent', 7, function ( assert ) {
 	var p = $.client.profile();
-	var unknownOrType = function( val, type, summary ) {
-		return ok( typeof val === type || val === 'unknown', summary );
-	};
+	function unknownOrType( val, type, summary ) {
+		assert.ok( typeof val === type || val === 'unknown', summary );
+	}
 
-	equal( typeof p, 'object', 'profile returns an object' );
+	assert.equal( typeof p, 'object', 'profile returns an object' );
 	unknownOrType( p.layout, 'string', 'p.layout is a string (or "unknown")' );
 	unknownOrType( p.layoutVersion, 'number', 'p.layoutVersion is a number (or "unknown")' );
 	unknownOrType( p.platform, 'string', 'p.platform is a string (or "unknown")' );
 	unknownOrType( p.version, 'string', 'p.version is a string (or "unknown")' );
 	unknownOrType( p.versionBase, 'string', 'p.versionBase is a string (or "unknown")' );
-	equal( typeof p.versionNumber, 'number', 'p.versionNumber is a number' );
+	assert.equal( typeof p.versionNumber, 'number', 'p.versionNumber is a number' );
 });
 
 // Example from WikiEditor
@@ -271,20 +283,16 @@ var testMap = {
 	}
 };
 
-test( 'test', function() {
-	expect(1);
-
+QUnit.test( 'test', 1, function ( assert ) {
 	// .test() uses eval, make sure no exceptions are thrown
 	// then do a basic return value type check
 	var testMatch = $.client.test( testMap );
 
-	equal( typeof testMatch, 'boolean', 'test returns a boolean value' );
+	assert.equal( typeof testMatch, 'boolean', 'test returns a boolean value' );
 
 });
 
-test( 'User-agent matches against WikiEditor\'s compatibility map', function() {
-	expect( uacount * 2 ); // double since we test both LTR and RTL
-
+QUnit.test( 'User-agent matches against WikiEditor\'s compatibility map', uacount * 2, function ( assert ) {
 	var	$body = $( 'body' ),
 		bodyClasses = $body.attr( 'class' );
 
@@ -299,7 +307,7 @@ test( 'User-agent matches against WikiEditor\'s compatibility map', function() {
 			var testMatch = $.client.test( testMap, profile );
 			$body.removeClass( dir );
 
-			equal( testMatch, data.wikiEditor[dir], 'testing comparison based on ' + dir + ', ' + agent );
+			assert.equal( testMatch, data.wikiEditor[dir], 'testing comparison based on ' + dir + ', ' + agent );
 		});
 	});
 
diff --git a/tests/qunit/suites/resources/jquery/jquery.colorUtil.test.js b/tests/qunit/suites/resources/jquery/jquery.colorUtil.test.js
index 655ee564..7b37f5a0 100644
--- a/tests/qunit/suites/resources/jquery/jquery.colorUtil.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.colorUtil.test.js
@@ -1,40 +1,31 @@
-module( 'jquery.colorUtil', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.colorUtil, '$.colorUtil defined' );
-});
-
-test( 'getRGB', function() {
-	expect(18);
-
-	strictEqual( $.colorUtil.getRGB(), undefined, 'No arguments' );
-	strictEqual( $.colorUtil.getRGB( '' ), undefined, 'Empty string' );
-	deepEqual( $.colorUtil.getRGB( [0, 100, 255] ), [0, 100, 255], 'Parse array of rgb values' );
-	deepEqual( $.colorUtil.getRGB( 'rgb(0,100,255)' ), [0, 100, 255], 'Parse simple rgb string' );
-	deepEqual( $.colorUtil.getRGB( 'rgb(0, 100, 255)' ), [0, 100, 255], 'Parse simple rgb string with spaces' );
-	deepEqual( $.colorUtil.getRGB( 'rgb(0%,20%,40%)' ), [0, 51, 102], 'Parse rgb string with percentages' );
-	deepEqual( $.colorUtil.getRGB( 'rgb(0%, 20%, 40%)' ), [0, 51, 102], 'Parse rgb string with percentages and spaces' );
-	deepEqual( $.colorUtil.getRGB( '#f2ddee' ), [242, 221, 238], 'Hex string: 6 char lowercase' );
-	deepEqual( $.colorUtil.getRGB( '#f2DDEE' ), [242, 221, 238], 'Hex string: 6 char uppercase' );
-	deepEqual( $.colorUtil.getRGB( '#f2DdEe' ), [242, 221, 238], 'Hex string: 6 char mixed' );
-	deepEqual( $.colorUtil.getRGB( '#eee' ), [238, 238, 238], 'Hex string: 3 char lowercase' );
-	deepEqual( $.colorUtil.getRGB( '#EEE' ), [238, 238, 238], 'Hex string: 3 char uppercase' );
-	deepEqual( $.colorUtil.getRGB( '#eEe' ), [238, 238, 238], 'Hex string: 3 char mixed' );
-	deepEqual( $.colorUtil.getRGB( 'rgba(0, 0, 0, 0)' ), [255, 255, 255], 'Zero rgba for Safari 3; Transparent (whitespace)' );
+QUnit.module( 'jquery.colorUtil', QUnit.newMwEnvironment() );
+
+QUnit.test( 'getRGB', 18, function ( assert ) {
+	assert.strictEqual( $.colorUtil.getRGB(), undefined, 'No arguments' );
+	assert.strictEqual( $.colorUtil.getRGB( '' ), undefined, 'Empty string' );
+	assert.deepEqual( $.colorUtil.getRGB( [0, 100, 255] ), [0, 100, 255], 'Parse array of rgb values' );
+	assert.deepEqual( $.colorUtil.getRGB( 'rgb(0,100,255)' ), [0, 100, 255], 'Parse simple rgb string' );
+	assert.deepEqual( $.colorUtil.getRGB( 'rgb(0, 100, 255)' ), [0, 100, 255], 'Parse simple rgb string with spaces' );
+	assert.deepEqual( $.colorUtil.getRGB( 'rgb(0%,20%,40%)' ), [0, 51, 102], 'Parse rgb string with percentages' );
+	assert.deepEqual( $.colorUtil.getRGB( 'rgb(0%, 20%, 40%)' ), [0, 51, 102], 'Parse rgb string with percentages and spaces' );
+	assert.deepEqual( $.colorUtil.getRGB( '#f2ddee' ), [242, 221, 238], 'Hex string: 6 char lowercase' );
+	assert.deepEqual( $.colorUtil.getRGB( '#f2DDEE' ), [242, 221, 238], 'Hex string: 6 char uppercase' );
+	assert.deepEqual( $.colorUtil.getRGB( '#f2DdEe' ), [242, 221, 238], 'Hex string: 6 char mixed' );
+	assert.deepEqual( $.colorUtil.getRGB( '#eee' ), [238, 238, 238], 'Hex string: 3 char lowercase' );
+	assert.deepEqual( $.colorUtil.getRGB( '#EEE' ), [238, 238, 238], 'Hex string: 3 char uppercase' );
+	assert.deepEqual( $.colorUtil.getRGB( '#eEe' ), [238, 238, 238], 'Hex string: 3 char mixed' );
+	assert.deepEqual( $.colorUtil.getRGB( 'rgba(0, 0, 0, 0)' ), [255, 255, 255], 'Zero rgba for Safari 3; Transparent (whitespace)' );
 
 	// Perhaps this is a bug in colorUtil, but it is the current behaviour so, let's keep
 	// track of it, so we will know in case it would ever change.
-	strictEqual( $.colorUtil.getRGB( 'rgba(0,0,0,0)' ), undefined, 'Zero rgba without whitespace' );
+	assert.strictEqual( $.colorUtil.getRGB( 'rgba(0,0,0,0)' ), undefined, 'Zero rgba without whitespace' );
 
-	deepEqual( $.colorUtil.getRGB( 'lightGreen' ), [144, 238, 144], 'Color names (lightGreen)' );
-	deepEqual( $.colorUtil.getRGB( 'transparent' ), [255, 255, 255], 'Color names (transparent)' );
-	strictEqual( $.colorUtil.getRGB( 'mediaWiki' ), undefined, 'Inexisting color name' );
+	assert.deepEqual( $.colorUtil.getRGB( 'lightGreen' ), [144, 238, 144], 'Color names (lightGreen)' );
+	assert.deepEqual( $.colorUtil.getRGB( 'transparent' ), [255, 255, 255], 'Color names (transparent)' );
+	assert.strictEqual( $.colorUtil.getRGB( 'mediaWiki' ), undefined, 'Inexisting color name' );
 });
 
-test( 'rgbToHsl', function() {
-	expect(1);
-
+QUnit.test( 'rgbToHsl', 1, function ( assert ) {
 	var hsl = $.colorUtil.rgbToHsl( 144, 238, 144 );
 
 	// Cross-browser differences in decimals...
@@ -45,27 +36,23 @@ test( 'rgbToHsl', function() {
 	// Re-create the rgbToHsl return array items, limited to two decimals.
 	var ret = [dualDecimals(hsl[0]), dualDecimals(hsl[1]), dualDecimals(hsl[2])];
 
-	deepEqual( ret, [0.33, 0.73, 0.75], 'rgb(144, 238, 144): hsl(0.33, 0.73, 0.75)' );
+	assert.deepEqual( ret, [0.33, 0.73, 0.75], 'rgb(144, 238, 144): hsl(0.33, 0.73, 0.75)' );
 });
 
-test( 'hslToRgb', function() {
-	expect(1);
-
+QUnit.test( 'hslToRgb', 1, function ( assert ) {
 	var rgb = $.colorUtil.hslToRgb( 0.3, 0.7, 0.8 );
 
 	// Cross-browser differences in decimals...
 	// Re-create the hslToRgb return array items, rounded to whole numbers.
 	var ret = [Math.round(rgb[0]), Math.round(rgb[1]), Math.round(rgb[2])];
 
-	deepEqual( ret ,[183, 240, 168], 'hsl(0.3, 0.7, 0.8): rgb(183, 240, 168)' );
+	assert.deepEqual( ret ,[183, 240, 168], 'hsl(0.3, 0.7, 0.8): rgb(183, 240, 168)' );
 });
 
-test( 'getColorBrightness', function() {
-	expect(2);
-
+QUnit.test( 'getColorBrightness', 2, function ( assert ) {
 	var a = $.colorUtil.getColorBrightness( 'red', +0.1 );
-	equal( a, 'rgb(255,50,50)', 'Start with named color "red", brighten 10%' );
+	assert.equal( a, 'rgb(255,50,50)', 'Start with named color "red", brighten 10%' );
 
 	var b = $.colorUtil.getColorBrightness( 'rgb(200,50,50)', -0.2 );
-	equal( b, 'rgb(118,29,29)', 'Start with rgb string "rgb(200,50,50)", darken 20%' );
+	assert.equal( b, 'rgb(118,29,29)', 'Start with rgb string "rgb(200,50,50)", darken 20%' );
 });
diff --git a/tests/qunit/suites/resources/jquery/jquery.delayedBind.test.js b/tests/qunit/suites/resources/jquery/jquery.delayedBind.test.js
index 6489a1f1..a3079835 100644
--- a/tests/qunit/suites/resources/jquery/jquery.delayedBind.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.delayedBind.test.js
@@ -1,41 +1,35 @@
-test('jquery.delayedBind with data option', function() {
+QUnit.asyncTest('jquery.delayedBind with data option', 2, function ( assert ) {
 	var $fixture = $('<div>').appendTo('#qunit-fixture'),
 		data = { magic: "beeswax" },
 		delay = 50;
 
-	$fixture.delayedBind(delay, 'testevent', data, function(event) {
-		start(); // continue!
-		ok(true, 'testevent fired');
-		ok(event.data === data, 'data is passed through delayedBind');
+	$fixture.delayedBind(delay, 'testevent', data, function ( e ) {
+		QUnit.start(); // continue!
+		assert.ok( true, 'testevent fired');
+		assert.ok( e.data === data, 'data is passed through delayedBind');
 	});
 
-	expect(2);
-	stop(); // async!
-
 	// We'll trigger it thrice, but it should only happen once.
-	$fixture.trigger('testevent', {});
-	$fixture.trigger('testevent', {});
-	$fixture.trigger('testevent', {});
-	$fixture.trigger('testevent', {});
+	$fixture.trigger( 'testevent', {} );
+	$fixture.trigger( 'testevent', {} );
+	$fixture.trigger( 'testevent', {} );
+	$fixture.trigger( 'testevent', {} );
 });
 
-test('jquery.delayedBind without data option', function() {
+QUnit.asyncTest('jquery.delayedBind without data option', 1, function ( assert ) {
 	var $fixture = $('<div>').appendTo('#qunit-fixture'),
 		data = { magic: "beeswax" },
 		delay = 50;
 
-	$fixture.delayedBind(delay, 'testevent', function(event) {
-		start(); // continue!
-		ok(true, 'testevent fired');
+	$fixture.delayedBind(delay, 'testevent', function ( e ) {
+		QUnit.start(); // continue!
+		assert.ok(true, 'testevent fired');
 	});
 
-	expect(1);
-	stop(); // async!
-
 	// We'll trigger it thrice, but it should only happen once.
-	$fixture.trigger('testevent', {});
-	$fixture.trigger('testevent', {});
-	$fixture.trigger('testevent', {});
-	$fixture.trigger('testevent', {});
+	$fixture.trigger( 'testevent', {} );
+	$fixture.trigger( 'testevent', {} );
+	$fixture.trigger( 'testevent', {} );
+	$fixture.trigger( 'testevent', {} );
 });
 
diff --git a/tests/qunit/suites/resources/jquery/jquery.getAttrs.test.js b/tests/qunit/suites/resources/jquery/jquery.getAttrs.test.js
index 9377a2f6..6eef1abb 100644
--- a/tests/qunit/suites/resources/jquery/jquery.getAttrs.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.getAttrs.test.js
@@ -1,17 +1,11 @@
-module( 'jquery.getAttrs', QUnit.newMwEnvironment() );
+QUnit.module( 'jquery.getAttrs', QUnit.newMwEnvironment() );
 
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.fn.getAttrs, 'jQuery.fn.getAttrs defined' );
-} );
-
-test( 'Check', function() {
-	expect(1);
+QUnit.test( 'Check', 1, function ( assert ) {
 	var	attrs = {
 			foo: 'bar',
 			'class': 'lorem'
 		},
-		$el = $( '<div>', attrs );
+		$el = jQuery( '<div>', attrs );
 
-	deepEqual( $el.getAttrs(), attrs, 'getAttrs() return object should match the attributes set, no more, no less' );
+	assert.deepEqual( $el.getAttrs(), attrs, 'getAttrs() return object should match the attributes set, no more, no less' );
 } );
diff --git a/tests/qunit/suites/resources/jquery/jquery.highlightText.test.js b/tests/qunit/suites/resources/jquery/jquery.highlightText.test.js
index 4750d2b8..a94dca31 100644
--- a/tests/qunit/suites/resources/jquery/jquery.highlightText.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.highlightText.test.js
@@ -1,12 +1,7 @@
-module( 'jquery.highlightText', QUnit.newMwEnvironment() );
+QUnit.module( 'jquery.highlightText', QUnit.newMwEnvironment() );
 
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.fn.highlightText, 'jQuery.fn.highlightText defined' );
-} );
-
-test( 'Check', function() {
-	var cases = [
+QUnit.test( 'Check', function ( assert ) {
+	var $fixture, cases = [
 		{
 		        desc: 'Test 001',
 			text: 'Blue Öyster Cult',
@@ -224,16 +219,14 @@ test( 'Check', function() {
 			expected: '<span class="highlight">بو</span>ل إيردوس'
 		}
 	];
-	expect(cases.length);
-	var $fixture;
+	QUnit.expect( cases.length );
 
-	$.each(cases, function( i, item ) {
-		$fixture = $( '<p></p>' ).text( item.text );
-		$fixture.highlightText( item.highlight );
-		equals(
+	$.each( cases, function ( i, item ) {
+		$fixture = $( '<p>' ).text( item.text ).highlightText( item.highlight );
+		assert.equal(
 			$fixture.html(),
-			$('<p>' + item.expected + '</p>').html(), // re-parse to normalize!
+			$( '<p>' ).html( item.expected ).html(), // re-parse to normalize!
 			item.desc || undefined
-			);
+		);
 	} );
 } );
diff --git a/tests/qunit/suites/resources/jquery/jquery.localize.test.js b/tests/qunit/suites/resources/jquery/jquery.localize.test.js
index cd828634..c8e1d9f9 100644
--- a/tests/qunit/suites/resources/jquery/jquery.localize.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.localize.test.js
@@ -1,13 +1,6 @@
-module( 'jquery.localize', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.fn.localize, 'jQuery.fn.localize defined' );
-} );
-
-test( 'Handle basic replacements', function() {
-	expect(3);
+QUnit.module( 'jquery.localize', QUnit.newMwEnvironment() );
 
+QUnit.test( 'Handle basic replacements', 4, function ( assert ) {
 	var html, $lc;
 	mw.messages.set( 'basic', 'Basic stuff' );
 
@@ -15,24 +8,28 @@ test( 'Handle basic replacements', function() {
 	html = '<div><span><html:msg key="basic" /></span></div>';
 	$lc = $( html ).localize().find( 'span' );
 
-	strictEqual( $lc.text(), 'Basic stuff', 'Tag: html:msg' );
+	assert.strictEqual( $lc.text(), 'Basic stuff', 'Tag: html:msg' );
 
 	// Attribute: title-msg
-	html = '<div><span title-msg="basic" /></span></div>';
+	html = '<div><span title-msg="basic"></span></div>';
 	$lc = $( html ).localize().find( 'span' );
 
-	strictEqual( $lc.attr( 'title' ), 'Basic stuff', 'Attribute: title-msg' );
+	assert.strictEqual( $lc.attr( 'title' ), 'Basic stuff', 'Attribute: title-msg' );
 
 	// Attribute: alt-msg
-	html = '<div><span alt-msg="basic" /></span></div>';
+	html = '<div><span alt-msg="basic"></span></div>';
 	$lc = $( html ).localize().find( 'span' );
 
-	strictEqual( $lc.attr( 'alt' ), 'Basic stuff', 'Attribute: alt-msg' );
-} );
+	assert.strictEqual( $lc.attr( 'alt' ), 'Basic stuff', 'Attribute: alt-msg' );
 
-test( 'Proper escaping', function() {
-	expect(2);
+	// Attribute: placeholder-msg
+	html = '<div><input placeholder-msg="basic" /></div>';
+	$lc = $( html ).localize().find( 'input' );
 
+	assert.strictEqual( $lc.attr( 'placeholder' ), 'Basic stuff', 'Attribute: placeholder-msg' );
+} );
+
+QUnit.test( 'Proper escaping', 2, function ( assert ) {
 	var html, $lc;
 	mw.messages.set( 'properfoo', '<proper esc="test">' );
 
@@ -40,21 +37,19 @@ test( 'Proper escaping', function() {
 	// making sure it is actually using text() and attr() (or something with the same effect)
 
 	// Text escaping
-	html = '<div><span><html:msg key="properfoo" /></span></div>';
+	html = '<div><span><html:msg key="properfoo"></span></div>';
 	$lc = $( html ).localize().find( 'span' );
 
-	strictEqual( $lc.text(), mw.msg( 'properfoo' ), 'Content is inserted as text, not as html.' );
+	assert.strictEqual( $lc.text(), mw.msg( 'properfoo' ), 'Content is inserted as text, not as html.' );
 
 	// Attribute escaping
-	html = '<div><span title-msg="properfoo" /></span></div>';
+	html = '<div><span title-msg="properfoo"></span></div>';
 	$lc = $( html ).localize().find( 'span' );
 
-	strictEqual( $lc.attr( 'title' ), mw.msg( 'properfoo' ), 'Attributes are not inserted raw.' );
+	assert.strictEqual( $lc.attr( 'title' ), mw.msg( 'properfoo' ), 'Attributes are not inserted raw.' );
 } );
 
-test( 'Options', function() {
-	expect(7);
-
+QUnit.test( 'Options', 7, function ( assert ) {
 	mw.messages.set( {
 		'foo-lorem': 'Lorem',
 		'foo-ipsum': 'Ipsum',
@@ -67,17 +62,17 @@ test( 'Options', function() {
 	var html, $lc, attrs, x, sitename = 'Wikipedia';
 
 	// Message key prefix
-	html = '<div><span title-msg="lorem"><html:msg key="ipsum" /></span></div>';
+	html = '<div><span title-msg="lorem"><html:msg key="ipsum"></span></div>';
 	$lc = $( html ).localize( {
 		prefix: 'foo-'
 	} ).find( 'span' );
 
-	strictEqual( $lc.attr( 'title' ), 'Lorem', 'Message key prefix - attr' );
-	strictEqual( $lc.text(), 'Ipsum', 'Message key prefix - text' );
+	assert.strictEqual( $lc.attr( 'title' ), 'Lorem', 'Message key prefix - attr' );
+	assert.strictEqual( $lc.text(), 'Ipsum', 'Message key prefix - text' );
 
 	// Variable keys mapping
 	x = 'bar';
-	html = '<div><span title-msg="title"><html:msg key="label" /></span></div>';
+	html = '<div><span title-msg="title"><html:msg key="label"></span></div>';
 	$lc = $( html ).localize( {
 		keys: {
 			'title': 'foo-' + x + '-title',
@@ -85,22 +80,22 @@ test( 'Options', function() {
 		}
 	} ).find( 'span' );
 
-	strictEqual( $lc.attr( 'title' ), 'Read more about bars', 'Variable keys mapping - attr' );
-	strictEqual( $lc.text(), 'The Bars', 'Variable keys mapping - text' );
+	assert.strictEqual( $lc.attr( 'title' ), 'Read more about bars', 'Variable keys mapping - attr' );
+	assert.strictEqual( $lc.text(), 'The Bars', 'Variable keys mapping - text' );
 
 	// Passing parameteters to mw.msg
-	html = '<div><span><html:msg key="foo-welcome" /></span></div>';
+	html = '<div><span><html:msg key="foo-welcome"></span></div>';
 	$lc = $( html ).localize( {
 		params: {
 			'foo-welcome': [sitename, 'yesterday']
 		}
 	} ).find( 'span' );
 
-	strictEqual( $lc.text(), 'Welcome to Wikipedia! (last visit: yesterday)', 'Passing parameteters to mw.msg' );
+	assert.strictEqual( $lc.text(), 'Welcome to Wikipedia! (last visit: yesterday)', 'Passing parameteters to mw.msg' );
 
 	// Combination of options prefix, params and keys
 	x = 'bazz';
-	html = '<div><span title-msg="title"><html:msg key="label" /></span></div>';
+	html = '<div><span title-msg="title"><html:msg key="label"></span></div>';
 	$lc = $( html ).localize( {
 		prefix: 'foo-',
 		keys: {
@@ -114,6 +109,25 @@ test( 'Options', function() {
 		}
 	} ).find( 'span' );
 
-	strictEqual( $lc.text(), 'The Bazz (Wikipedia)', 'Combination of options prefix, params and keys - text' );
-	strictEqual( $lc.attr( 'title' ), 'Read more about bazz at Wikipedia (last modified: 3 minutes ago)', 'Combination of options prefix, params and keys - attr' );
+	assert.strictEqual( $lc.text(), 'The Bazz (Wikipedia)', 'Combination of options prefix, params and keys - text' );
+	assert.strictEqual( $lc.attr( 'title' ), 'Read more about bazz at Wikipedia (last modified: 3 minutes ago)', 'Combination of options prefix, params and keys - attr' );
+} );
+
+QUnit.test( 'Handle data text', 2, function ( assert ) {
+	var html, $lc;
+	mw.messages.set( 'option-one', 'Item 1' );
+	mw.messages.set( 'option-two', 'Item 2' );
+	html = '<select><option data-msg-text="option-one"></option><option data-msg-text="option-two"></option></select>';
+	$lc = $( html ).localize().find( 'option' );
+	assert.strictEqual( $lc.eq( 0 ).text(), mw.msg( 'option-one' ), 'data-msg-text becomes text of options' );
+	assert.strictEqual( $lc.eq( 1 ).text(), mw.msg( 'option-two' ), 'data-msg-text becomes text of options' );
+} );
+
+QUnit.test( 'Handle data html', 2, function ( assert ) {
+	var html, $lc;
+	mw.messages.set( 'html', 'behold... there is a <a>link</a> here!!' );
+	html = '<div><div data-msg-html="html"></div></div>';
+	$lc = $( html ).localize().find( 'a' );
+	assert.strictEqual( $lc.length, 1, 'link is created' );
+	assert.strictEqual( $lc.text(), 'link', 'the link text got added' );
 } );
diff --git a/tests/qunit/suites/resources/jquery/jquery.mwExtension.test.js b/tests/qunit/suites/resources/jquery/jquery.mwExtension.test.js
index 3a2d0d83..5b566ae0 100644
--- a/tests/qunit/suites/resources/jquery/jquery.mwExtension.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.mwExtension.test.js
@@ -1,58 +1,58 @@
-module( 'jquery.mwExtension', QUnit.newMwEnvironment() );
+QUnit.module( 'jquery.mwExtension', QUnit.newMwEnvironment() );
 
-test( 'String functions', function() {
+QUnit.test( 'String functions', function ( assert ) {
 
-	equal( $.trimLeft( '  foo bar  ' ), 'foo bar  ', 'trimLeft' );
-	equal( $.trimRight( '  foo bar  ' ), '  foo bar', 'trimRight' );
-	equal( $.ucFirst( 'foo' ), 'Foo', 'ucFirst' );
+	assert.equal( $.trimLeft( '  foo bar  ' ), 'foo bar  ', 'trimLeft' );
+	assert.equal( $.trimRight( '  foo bar  ' ), '  foo bar', 'trimRight' );
+	assert.equal( $.ucFirst( 'foo' ), 'Foo', 'ucFirst' );
 
-	equal( $.escapeRE( '<!-- ([{+mW+}]) $^|?>' ),
+	assert.equal( $.escapeRE( '<!-- ([{+mW+}]) $^|?>' ),
 	 '<!\\-\\- \\(\\[\\{\\+mW\\+\\}\\]\\) \\$\\^\\|\\?>', 'escapeRE - Escape specials' );
-	equal( $.escapeRE( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ),
+	assert.equal( $.escapeRE( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ),
 	 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'escapeRE - Leave uppercase alone' );
-	equal( $.escapeRE( 'abcdefghijklmnopqrstuvwxyz' ),
+	assert.equal( $.escapeRE( 'abcdefghijklmnopqrstuvwxyz' ),
 	 'abcdefghijklmnopqrstuvwxyz', 'escapeRE - Leave lowercase alone' );
-	equal( $.escapeRE( '0123456789' ), '0123456789', 'escapeRE - Leave numbers alone' );
+	assert.equal( $.escapeRE( '0123456789' ), '0123456789', 'escapeRE - Leave numbers alone' );
 });
 
-test( 'Is functions', function() {
+QUnit.test( 'Is functions', function ( assert ) {
 
-	strictEqual( $.isDomElement( document.getElementById( 'qunit-header' ) ), true,
+	assert.strictEqual( $.isDomElement( document.getElementById( 'qunit-header' ) ), true,
 	 'isDomElement: #qunit-header Node' );
-	strictEqual( $.isDomElement( document.getElementById( 'random-name' ) ), false,
+	assert.strictEqual( $.isDomElement( document.getElementById( 'random-name' ) ), false,
 	 'isDomElement: #random-name (null)' );
-	strictEqual( $.isDomElement( document.getElementsByTagName( 'div' ) ), false,
+	assert.strictEqual( $.isDomElement( document.getElementsByTagName( 'div' ) ), false,
 	 'isDomElement: getElementsByTagName Array' );
-	strictEqual( $.isDomElement( document.getElementsByTagName( 'div' )[0] ), true,
+	assert.strictEqual( $.isDomElement( document.getElementsByTagName( 'div' )[0] ), true,
 	 'isDomElement: getElementsByTagName(..)[0] Node' );
-	strictEqual( $.isDomElement( $( 'div' ) ), false,
+	assert.strictEqual( $.isDomElement( $( 'div' ) ), false,
 	 'isDomElement: jQuery object' );
-	strictEqual( $.isDomElement( $( 'div' ).get(0) ), true,
+	assert.strictEqual( $.isDomElement( $( 'div' ).get(0) ), true,
 	 'isDomElement: jQuery object > Get node' );
-	strictEqual( $.isDomElement( document.createElement( 'div' ) ), true,
+	assert.strictEqual( $.isDomElement( document.createElement( 'div' ) ), true,
 	 'isDomElement: createElement' );
-	strictEqual( $.isDomElement( { foo: 1 } ), false,
+	assert.strictEqual( $.isDomElement( { foo: 1 } ), false,
 	 'isDomElement: Object' );
 
-	strictEqual( $.isEmpty( 'string' ), false, 'isEmptry: "string"' );
-	strictEqual( $.isEmpty( '0' ), true, 'isEmptry: "0"' );
-	strictEqual( $.isEmpty( '' ), true, 'isEmptry: ""' );
-	strictEqual( $.isEmpty( 1 ), false, 'isEmptry: 1' );
-	strictEqual( $.isEmpty( [] ), true, 'isEmptry: []' );
-	strictEqual( $.isEmpty( {} ), true, 'isEmptry: {}' );
+	assert.strictEqual( $.isEmpty( 'string' ), false, 'isEmptry: "string"' );
+	assert.strictEqual( $.isEmpty( '0' ), true, 'isEmptry: "0"' );
+	assert.strictEqual( $.isEmpty( '' ), true, 'isEmptry: ""' );
+	assert.strictEqual( $.isEmpty( 1 ), false, 'isEmptry: 1' );
+	assert.strictEqual( $.isEmpty( [] ), true, 'isEmptry: []' );
+	assert.strictEqual( $.isEmpty( {} ), true, 'isEmptry: {}' );
 
 	// Documented behaviour
-	strictEqual( $.isEmpty( { length: 0 } ), true, 'isEmptry: { length: 0 }' );
+	assert.strictEqual( $.isEmpty( { length: 0 } ), true, 'isEmptry: { length: 0 }' );
 });
 
-test( 'Comparison functions', function() {
+QUnit.test( 'Comparison functions', function ( assert ) {
 
-	ok( $.compareArray( [0, 'a', [], [2, 'b'] ], [0, "a", [], [2, "b"] ] ),
+	assert.ok( $.compareArray( [0, 'a', [], [2, 'b'] ], [0, "a", [], [2, "b"] ] ),
 	 'compareArray: Two deep arrays that are excactly the same' );
-	ok( !$.compareArray( [1], [2] ), 'compareArray: Two different arrays (false)' );
+	assert.ok( !$.compareArray( [1], [2] ), 'compareArray: Two different arrays (false)' );
 
-	ok( $.compareObject( {}, {} ), 'compareObject: Two empty objects' );
-	ok( $.compareObject( { foo: 1 }, { foo: 1 } ), 'compareObject: Two the same objects' );
-	ok( !$.compareObject( { bar: true }, { baz: false } ),
+	assert.ok( $.compareObject( {}, {} ), 'compareObject: Two empty objects' );
+	assert.ok( $.compareObject( { foo: 1 }, { foo: 1 } ), 'compareObject: Two the same objects' );
+	assert.ok( !$.compareObject( { bar: true }, { baz: false } ),
 	 'compareObject: Two different objects (false)' );
 });
diff --git a/tests/qunit/suites/resources/jquery/jquery.tabIndex.test.js b/tests/qunit/suites/resources/jquery/jquery.tabIndex.test.js
index 98ff5508..161f0cd1 100644
--- a/tests/qunit/suites/resources/jquery/jquery.tabIndex.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.tabIndex.test.js
@@ -1,15 +1,6 @@
-module( 'jquery.tabIndex', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(2);
-
-	ok( $.fn.firstTabIndex, '$.fn.firstTabIndex defined' );
-	ok( $.fn.lastTabIndex, '$.fn.lastTabIndex defined' );
-});
-
-test( 'firstTabIndex', function() {
-	expect(2);
+QUnit.module( 'jquery.tabIndex', QUnit.newMwEnvironment() );
 
+QUnit.test( 'firstTabIndex', 2, function ( assert ) {
 	var testEnvironment =
 '<form>' +
 	'<input tabindex="7" />' +
@@ -19,15 +10,13 @@ test( 'firstTabIndex', function() {
 '</form>';
 
 	var $testA = $( '<div>' ).html( testEnvironment ).appendTo( '#qunit-fixture' );
-	strictEqual( $testA.firstTabIndex(), 2, 'First tabindex should be 2 within this context.' );
+	assert.strictEqual( $testA.firstTabIndex(), 2, 'First tabindex should be 2 within this context.' );
 
 	var $testB = $( '<div>' );
-	strictEqual( $testB.firstTabIndex(), null, 'Return null if none available.' );
+	assert.strictEqual( $testB.firstTabIndex(), null, 'Return null if none available.' );
 });
 
-test( 'lastTabIndex', function() {
-	expect(2);
-
+QUnit.test( 'lastTabIndex', 2, function ( assert ) {
 	var testEnvironment =
 '<form>' +
 	'<input tabindex="7" />' +
@@ -37,8 +26,8 @@ test( 'lastTabIndex', function() {
 '</form>';
 
 	var $testA = $( '<div>' ).html( testEnvironment ).appendTo( '#qunit-fixture' );
-	strictEqual( $testA.lastTabIndex(), 9, 'Last tabindex should be 9 within this context.' );
+	assert.strictEqual( $testA.lastTabIndex(), 9, 'Last tabindex should be 9 within this context.' );
 
 	var $testB = $( '<div>' );
-	strictEqual( $testB.lastTabIndex(), null, 'Return null if none available.' );
+	assert.strictEqual( $testB.lastTabIndex(), null, 'Return null if none available.' );
 });
diff --git a/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js b/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js
index 7ecdc4b1..16d81707 100644
--- a/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.tablesorter.test.js
@@ -1,4 +1,4 @@
-( function () {
+( function ( $, mw ) {
 
 var config = {
 	wgMonthNames: ['', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
@@ -7,12 +7,7 @@ var config = {
 	wgContentLanguage: 'en'
 };
 
-module( 'jquery.tablesorter', QUnit.newMwEnvironment( config ) );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.tablesorter, '$.tablesorter defined' );
-});
+QUnit.module( 'jquery.tablesorter', QUnit.newMwEnvironment({ config: config }) );
 
 /**
  * Create an HTML table from an array of row arrays containing text strings.
@@ -22,28 +17,29 @@ test( '-- Initial check', function() {
  * @param {String[][]} data
  * @return jQuery
  */
-var tableCreate = function( header, data ) {
-	var $table = $( '<table class="sortable"><thead></thead><tbody></tbody></table>' ),
+function tableCreate(  header, data ) {
+	var i,
+		$table = $( '<table class="sortable"><thead></thead><tbody></tbody></table>' ),
 		$thead = $table.find( 'thead' ),
 		$tbody = $table.find( 'tbody' ),
 		$tr = $( '<tr>' );
 
-	$.each( header, function( i, str ) {
+	$.each( header, function ( i, str ) {
 		var $th = $( '<th>' );
 		$th.text( str ).appendTo( $tr );
 	});
 	$tr.appendTo( $thead );
 
-	for (var i = 0; i < data.length; i++) {
+	for ( i = 0; i < data.length; i++ ) {
 		$tr = $( '<tr>' );
-		$.each( data[i], function( j, str ) {
+		$.each( data[i], function ( j, str ) {
 			var $td = $( '<td>' );
 			$td.text( str ).appendTo( $tr );
 		});
 		$tr.appendTo( $tbody );
 	}
 	return $table;
-};
+}
 
 /**
  * Extract text from table.
@@ -51,7 +47,7 @@ var tableCreate = function( header, data ) {
  * @param {jQuery} $table
  * @return String[][]
  */
-var tableExtract = function( $table ) {
+function tableExtract( $table ) {
 	var data = [];
 
 	$table.find( 'tbody' ).find( 'tr' ).each( function( i, tr ) {
@@ -62,7 +58,7 @@ var tableExtract = function( $table ) {
 		data.push( row );
 	});
 	return data;
-};
+}
 
 /**
  * Run a table test by building a table with the given data,
@@ -74,10 +70,8 @@ var tableExtract = function( $table ) {
  * @param {String[][]} expected rows/cols to compare against at end
  * @param {function($table)} callback something to do with the table before we compare
  */
-var tableTest = function( msg, header, data, expected, callback ) {
-	test( msg, function() {
-		expect(1);
-
+function tableTest( msg, header, data, expected, callback ) {
+	QUnit.test( msg, 1, function ( assert ) {
 		var $table = tableCreate( header, data );
 
 		// Give caller a chance to set up sorting and manipulate the table.
@@ -86,15 +80,18 @@ var tableTest = function( msg, header, data, expected, callback ) {
 		// Table sorting is done synchronously; if it ever needs to change back
 		// to asynchronous, we'll need a timeout or a callback here.
 		var extracted = tableExtract( $table );
-		deepEqual( extracted, expected, msg );
+		assert.deepEqual( extracted, expected, msg );
 	});
-};
+}
 
-var reversed = function(arr) {
+function reversed(arr) {
+	// Clone array
 	var arr2 = arr.slice(0);
+
 	arr2.reverse();
+
 	return arr2;
-};
+}
 
 // Sample data set using planets named and their radius
 var header  = [ 'Planet' , 'Radius (km)'],
@@ -115,7 +112,7 @@ tableTest(
 	header,
 	planets,
 	ascendingName,
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(0)' ).click();
 	}
@@ -125,7 +122,7 @@ tableTest(
 	header,
 	planets,
 	ascendingName,
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(0)' ).click();
 	}
@@ -135,7 +132,7 @@ tableTest(
 	header,
 	planets,
 	reversed(ascendingName),
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(0)' ).click().click();
 	}
@@ -145,7 +142,7 @@ tableTest(
 	header,
 	planets,
 	ascendingRadius,
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(1)' ).click();
 	}
@@ -155,7 +152,7 @@ tableTest(
 	header,
 	planets,
 	reversed(ascendingRadius),
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(1)' ).click().click();
 	}
@@ -180,7 +177,7 @@ tableTest(
 		['09.11.2011'],
 		['11.11.2011']
 	],
-	function( $table ) {
+	function ( $table ) {
 		mw.config.set( 'wgDefaultDateFormat', 'dmy' );
 		mw.config.set( 'wgContentLanguage', 'de' );
 
@@ -206,7 +203,7 @@ tableTest(
 		['09.11.2011'],
 		['11.11.2011']
 	],
-	function( $table ) {
+	function ( $table ) {
 		mw.config.set( 'wgDefaultDateFormat', 'mdy' );
 
 		$table.tablesorter();
@@ -242,7 +239,7 @@ tableTest(
 	['IP'],
 	ipv4,
 	ipv4Sorted,
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(0)' ).click();
 	}
@@ -252,7 +249,7 @@ tableTest(
 	['IP'],
 	ipv4,
 	reversed(ipv4Sorted),
-	function( $table ) {
+	function ( $table ) {
 		$table.tablesorter();
 		$table.find( '.headerSort:eq(0)' ).click().click();
 	}
@@ -287,7 +284,7 @@ tableTest(
 	['Name'],
 	umlautWords,
 	umlautWordsSorted,
-	function( $table ) {
+	function ( $table ) {
 		mw.config.set( 'tableSorterCollation', {
 			'ä': 'ae',
 			'ö': 'oe',
@@ -301,14 +298,14 @@ tableTest(
 );
 
 var planetsRowspan = [["Earth","6051.8"], jupiter, ["Mars","6051.8"], mercury, saturn, venus];
-var planetsRowspanII = [jupiter, mercury, saturn, ['Venus', '6371.0'], venus, ['Venus', '3390.0']];
+var planetsRowspanII = [jupiter, mercury, saturn, venus, ['Venus', '6371.0'], ['Venus', '3390.0']];
 
 tableTest(
 	'Basic planet table: same value for multiple rows via rowspan',
 	header,
 	planets,
 	planetsRowspan,
-	function( $table ) {
+	function ( $table ) {
 		// Modify the table to have a multiuple-row-spanning cell:
 		// - Remove 2nd cell of 4th row, and, 2nd cell or 5th row.
 		$table.find( 'tr:eq(3) td:eq(1), tr:eq(4) td:eq(1)' ).remove();
@@ -325,7 +322,7 @@ tableTest(
 	header,
 	planets,
 	planetsRowspanII,
-	function( $table ) {
+	function ( $table ) {
 		// Modify the table to have a multiuple-row-spanning cell:
 		// - Remove 1st cell of 4th row, and, 1st cell or 5th row.
 		$table.find( 'tr:eq(3) td:eq(0), tr:eq(4) td:eq(0)' ).remove();
@@ -348,11 +345,11 @@ var complexMDYDates = [
 ];
 
 var complexMDYSorted = [
-	["5.12.1990"],
-	["April 21 1991"],
-	["04 22 1991"],
-	["January, 19 2010"],
-	["December 12 '10"]
+	['5.12.1990'],
+	['April 21 1991'],
+	['04 22 1991'],
+	['January, 19 2010'],
+	['December 12 \'10']
 ];
 
 tableTest(
@@ -360,7 +357,7 @@ tableTest(
 	['date'],
 	complexMDYDates,
 	complexMDYSorted,
-	function( $table ) {
+	function ( $table ) {
 		mw.config.set( 'wgDefaultDateFormat', 'mdy' );
 
 		$table.tablesorter();
@@ -368,6 +365,39 @@ tableTest(
 	}
 );
 
+var currencyUnsorted = [
+	['1.02 $'],
+	['$ 3.00'],
+	['€ 2,99'],
+	['$ 1.00'],
+	['$3.50'],
+	['$ 1.50'],
+	['€ 0.99']
+];
+
+var currencySorted = [
+	['€ 0.99'],
+	['$ 1.00'],
+	['1.02 $'],
+	['$ 1.50'],
+	['$ 3.00'],
+	['$3.50'],
+	// Comma's sort after dots
+	// Not intentional but test to detect changes
+	['€ 2,99']
+];
+
+tableTest(
+	'Currency parsing I',
+	['currency'],
+	currencyUnsorted,
+	currencySorted,
+	function ( $table ) {
+		$table.tablesorter();
+		$table.find( '.headerSort:eq(0)' ).click();
+	}
+);
+
 var ascendingNameLegacy = ascendingName.slice(0);
 ascendingNameLegacy[4] = ascendingNameLegacy[5];
 ascendingNameLegacy.pop();
@@ -384,8 +414,9 @@ tableTest(
 	}
 );
 
+
 /** FIXME: the diff output is not very readeable. */
-test( 'bug 32047 - caption must be before thead', function() {
+QUnit.test( 'bug 32047 - caption must be before thead', function ( assert ) {
 	var $table;
 	$table = $(
 		'<table class="sortable">' +
@@ -398,17 +429,18 @@ test( 'bug 32047 - caption must be before thead', function() {
 		);
 	$table.tablesorter();
 
-	equals(
+	assert.equal(
 		$table.children( ).get( 0 ).nodeName,
 		'CAPTION',
 		'First element after <thead> must be <caption> (bug 32047)'
 	);
 });
 
-test( 'data-sort-value attribute, when available, should override sorting position', function() {
+QUnit.test( 'data-sort-value attribute, when available, should override sorting position', function ( assert ) {
 	var $table, data;
 
-	// Simple example, one without data-sort-value which should be sorted at it's text.
+	// Example 1: All cells except one cell without data-sort-value,
+	// which should be sorted at it's text content value.
 	$table = $(
 		'<table class="sortable"><thead><tr><th>Data</th></tr></thead>' +
 			'<tbody>' +
@@ -424,30 +456,33 @@ test( 'data-sort-value attribute, when available, should override sorting positi
 	data = [];
 	$table.find( 'tbody > tr' ).each( function( i, tr ) {
 		$( tr ).find( 'td' ).each( function( i, td ) {
-			data.push( { data: $( td ).data( 'sort-value' ), text: $( td ).text() } );
+			data.push( {
+				data: $( td ).data( 'sortValue' ),
+				text: $( td ).text()
+			} );
 		});
 	});
 
-	deepEqual( data, [
+	assert.deepEqual( data, [
 		{
-			"data": "Apple",
-			"text": "Bird"
+			data: 'Apple',
+			text: 'Bird'
 		}, {
-			"data": "Bananna",
-			"text": "Ferret"
+			data: 'Bananna',
+			text: 'Ferret'
 		}, {
-			"data": undefined,
-			"text": "Cheetah"
+			data: undefined,
+			text: 'Cheetah'
 		}, {
-			"data": "Cherry",
-			"text": "Dolphin"
+			data: 'Cherry',
+			text: 'Dolphin'
 		}, {
-			"data": "Drupe",
-			"text": "Elephant"
+			data: 'Drupe',
+			text: 'Elephant'
 		}
-	] );
+	], 'Order matches expected order (based on data-sort-value attribute values)' );
 
-	// Another example
+	// Example 2
 	$table = $(
 		'<table class="sortable"><thead><tr><th>Data</th></tr></thead>' +
 			'<tbody>' +
@@ -461,30 +496,91 @@ test( 'data-sort-value attribute, when available, should override sorting positi
 	$table.tablesorter().find( '.headerSort:eq(0)' ).click();
 
 	data = [];
+	$table.find( 'tbody > tr' ).each( function ( i, tr ) {
+		$( tr ).find( 'td' ).each( function ( i, td ) {
+			data.push( {
+				data: $( td ).data( 'sortValue' ),
+				text: $( td ).text()
+			} );
+		});
+	});
+
+	assert.deepEqual( data, [
+		{
+			data: undefined,
+			text: 'B'
+		}, {
+			data: undefined,
+			text: 'D'
+		}, {
+			data: 'E',
+			text: 'A'
+		}, {
+			data: 'F',
+			text: 'C'
+		}, {
+			data: undefined,
+			text: 'G'
+		}
+	], 'Order matches expected order (based on data-sort-value attribute values)' );
+
+	// Example 3: Test that live changes are used from data-sort-value,
+	// even if they change after the tablesorter is constructed (bug 38152).
+	$table = $(
+		'<table class="sortable"><thead><tr><th>Data</th></tr></thead>' +
+			'<tbody>' +
+			'<tr><td>D</td></tr>' +
+			'<tr><td data-sort-value="1">A</td></tr>' +
+			'<tr><td>B</td></tr>' +
+			'<tr><td data-sort-value="2">G</td></tr>' +
+			'<tr><td>C</td></tr>' +
+		'</tbody></table>'
+	);
+	// initialize table sorter and sort once
+	$table
+		.tablesorter()
+		.find( '.headerSort:eq(0)' ).click();
+
+	// Change the sortValue data properties (bug 38152)
+	// - change data
+	$table.find( 'td:contains(A)' ).data( 'sortValue', 3 );
+	// - add data
+	$table.find( 'td:contains(B)' ).data( 'sortValue', 1 );
+	// - remove data, bring back attribute: 2
+	$table.find( 'td:contains(G)' ).removeData( 'sortValue' );
+
+	// Now sort again (twice, so it is back at Ascending)
+	$table.find( '.headerSort:eq(0)' ).click();
+	$table.find( '.headerSort:eq(0)' ).click();
+
+	data = [];
 	$table.find( 'tbody > tr' ).each( function( i, tr ) {
 		$( tr ).find( 'td' ).each( function( i, td ) {
-			data.push( { data: $( td ).data( 'sort-value' ), text: $( td ).text() } );
+			data.push( {
+				data: $( td ).data( 'sortValue' ),
+				text: $( td ).text()
+			} );
 		});
 	});
 
-	deepEqual( data, [
+	assert.deepEqual( data, [
 		{
-			"data": undefined,
-			"text": "B"
+			data: 1,
+			text: "B"
 		}, {
-			"data": undefined,
-			"text": "D"
+			data: 2,
+			text: "G"
 		}, {
-			"data": "E",
-			"text": "A"
+			data: 3,
+			text: "A"
 		}, {
-			"data": "F",
-			"text": "C"
+			data: undefined,
+			text: "C"
 		}, {
-			"data": undefined,
-			"text": "G"
+			data: undefined,
+			text: "D"
 		}
-	] );
+	], 'Order matches expected order, using the current sortValue in $.data()' );
 
 });
 
@@ -522,13 +618,11 @@ tableTest( 'bug 8115: sort numbers with commas (descending)',
 );
 // TODO add numbers sorting tests for bug 8115 with a different language
 
-test( 'bug 32888 - Tables inside a tableheader cell', function() {
-	expect(2);
-
+QUnit.test( 'bug 32888 - Tables inside a tableheader cell', 2, function ( assert ) {
 	var $table;
 	$table = $(
-		'<table class="sortable" id="32888">' +
-		'<tr><th>header<table id="32888-2">'+
+		'<table class="sortable" id="mw-bug-32888">' +
+		'<tr><th>header<table id="mw-bug-32888-2">'+
 			'<tr><th>1</th><th>2</th></tr>' +
 		'</table></th></tr>' +
 		'<tr><td>A</td></tr>' +
@@ -537,16 +631,67 @@ test( 'bug 32888 - Tables inside a tableheader cell', function() {
 		);
 	$table.tablesorter();
 
-	equals(
+	assert.equal(
 		$table.find('> thead:eq(0) > tr > th.headerSort').length,
 		1,
 		'Child tables inside a headercell should not interfere with sortable headers (bug 32888)'
 	);
-	equals(
-		$('#32888-2').find('th.headerSort').length,
+	assert.equal(
+		$( '#mw-bug-32888-2' ).find('th.headerSort').length,
 		0,
 		'The headers of child tables inside a headercell should not be sortable themselves (bug 32888)'
 	);
 });
 
-})();
+
+var correctDateSorting1 = [
+	['01 January 2010'],
+	['05 February 2010'],
+	['16 January 2010']
+];
+
+var correctDateSortingSorted1 = [
+	['01 January 2010'],
+	['16 January 2010'],
+	['05 February 2010']
+];
+
+tableTest(
+	'Correct date sorting I',
+	['date'],
+	correctDateSorting1,
+	correctDateSortingSorted1,
+	function ( $table ) {
+		mw.config.set( 'wgDefaultDateFormat', 'mdy' );
+
+		$table.tablesorter();
+		$table.find( '.headerSort:eq(0)' ).click();
+	}
+);
+
+var correctDateSorting2 = [
+	['January 01 2010'],
+	['February 05 2010'],
+	['January 16 2010']
+];
+
+var correctDateSortingSorted2 = [
+	['January 01 2010'],
+	['January 16 2010'],
+	['February 05 2010']
+];
+
+tableTest(
+	'Correct date sorting II',
+	['date'],
+	correctDateSorting2,
+	correctDateSortingSorted2,
+	function ( $table ) {
+		mw.config.set( 'wgDefaultDateFormat', 'dmy' );
+
+		$table.tablesorter();
+		$table.find( '.headerSort:eq(0)' ).click();
+	}
+);
+
+}( jQuery, mediaWiki ) );
diff --git a/tests/qunit/suites/resources/jquery/jquery.textSelection.test.js b/tests/qunit/suites/resources/jquery/jquery.textSelection.test.js
index 1b2f3024..f0a210f5 100644
--- a/tests/qunit/suites/resources/jquery/jquery.textSelection.test.js
+++ b/tests/qunit/suites/resources/jquery/jquery.textSelection.test.js
@@ -1,9 +1,4 @@
-module( 'jquery.textSelection', QUnit.newMwEnvironment() );
-
-test( '-- Initial check', function() {
-	expect(1);
-	ok( $.fn.textSelection, 'jQuery.fn.textSelection defined' );
-} );
+QUnit.module( 'jquery.textSelection', QUnit.newMwEnvironment() );
 
 /**
  * Test factory for $.fn.textSelection( 'encapsulateText' )
@@ -16,7 +11,7 @@ test( '-- Initial check', function() {
  *   end {int} ending char for selection
  *   params {object} add'l parameters for $().textSelection( 'encapsulateText' )
  */
-var encapsulateTest = function( options ) {
+function encapsulateTest( options ) {
 	var opt = $.extend({
 		description: '',
 		before: {},
@@ -34,12 +29,12 @@ var encapsulateTest = function( options ) {
 		selected: null
 	}, opt.after);
 
-	test( opt.description, function() {
+	QUnit.test( opt.description, function ( assert ) {
 		var tests = 1;
 		if ( opt.after.selected !== null ) {
 			tests++;
 		}
-		expect( tests );
+		QUnit.expect( tests );
 
 		var $textarea = $( '<textarea>' );
 
@@ -65,15 +60,15 @@ var encapsulateTest = function( options ) {
 
 		var text = $textarea.textSelection( 'getContents' ).replace( /\r\n/g, "\n" );
 
-		equal( text, opt.after.text, 'Checking full text after encapsulation' );
+		assert.equal( text, opt.after.text, 'Checking full text after encapsulation' );
 
 		if (opt.after.selected !== null) {
 			var selected = $textarea.textSelection( 'getSelection' );
-			equal( selected, opt.after.selected, 'Checking selected text after encapsulation.' );
+			assert.equal( selected, opt.after.selected, 'Checking selected text after encapsulation.' );
 		}
 
 	} );
-};
+}
 
 var sig = {
 	'pre': "--~~~~"
@@ -86,7 +81,7 @@ var sig = {
 	'peri': 'Heading 2',
 	'post': ' ==',
 	'regex': /^(\s*)(={1,6})(.*?)\2(\s*)$/,
-	'regexReplace': "\$1==\$3==\$4",
+	'regexReplace': "$1==$3==$4",
 	'ownline': true
 }, ulist = {
 	'pre': "* ",
@@ -222,28 +217,26 @@ encapsulateTest({
 });
 
 
-var caretTest = function(options) {
-	test(options.description, function() {
-		expect(2);
-
-		var $textarea = $( '<textarea>' ).text(options.text);
+function caretTest( options ) {
+	QUnit.test( options.description, 2, function ( assert ) {
+		var $textarea = $( '<textarea>' ).text( options.text );
 
 		$( '#qunit-fixture' ).append( $textarea );
 
-		if (options.mode == 'set') {
+		if ( options.mode === 'set' ) {
 			$textarea.textSelection('setSelection', {
 				start: options.start,
 				end: options.end
 			});
 		}
 
-		var among = function(actual, expected, message) {
-			if ($.isArray(expected)) {
-				ok($.inArray(actual, expected) !== -1 , message + ' (got ' + actual + '; expected one of ' + expected.join(', ') + ')');
+		function among( actual, expected, message ) {
+			if ( $.isArray( expected ) ) {
+				assert.ok( $.inArray( actual, expected ) !== -1 , message + ' (got ' + actual + '; expected one of ' + expected.join(', ') + ')' );
 			} else {
-				equal(actual, expected, message);
+				assert.equal( actual, expected, message );
 			}
-		};
+		}
 
 		var pos = $textarea.textSelection('getCaretPosition', {startAndEnd: true});
 		among(pos[0], options.start, 'Caret start should be where we set it.');
@@ -253,6 +246,8 @@ var caretTest = function(options) {
 
 var caretSample = "Some big text that we like to work with. Nothing fancy... you know what I mean?";
 
+/*
+ // @broken: Disabled per bug 34820
 caretTest({
 	description: 'getCaretPosition with original/empty selection - bug 31847 with IE 6/7/8',
 	text: caretSample,
@@ -260,6 +255,7 @@ caretTest({
 	end: [0, caretSample.length], // Other browsers default it to the beginning (0), so check both.
 	mode: 'get'
 });
+*/
 
 caretTest({
 	description: 'set/getCaretPosition with forced empty selection',
diff --git a/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.parse.test.js b/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.parse.test.js
new file mode 100644
index 00000000..3d3f630f
--- /dev/null
+++ b/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.parse.test.js
@@ -0,0 +1,26 @@
+QUnit.module( 'mediawiki.api.parse', QUnit.newMwEnvironment() );
+
+QUnit.asyncTest( 'Hello world', function ( assert ) {
+	var api;
+	QUnit.expect( 6 );
+
+	api = new mw.Api();
+
+	api.parse( "'''Hello world'''" )
+		.done( function ( html ) {
+			// Parse into a document fragment instead of comparing HTML, due to
+			// presence of Tidy influencing whitespace.
+			// Html also contains "NewPP report" comment.
+			var $res = $( '<div>' ).html( html ).children(),
+				res = $res.get( 0 );
+			assert.equal( $res.length, 1, 'Response contains 1 element' );
+			assert.equal( res.nodeName.toLowerCase(), 'p', 'Response is a paragraph' );
+			assert.equal( $res.children().length, 1, 'Response has 1 child element' );
+			assert.equal( $res.children().get( 0 ).nodeName.toLowerCase(), 'b', 'Child element is a bold tag' );
+			// Trim since Tidy may or may not mess with the spacing here
+			assert.equal( $.trim( $res.text() ), 'Hello world', 'Response contains given text' );
+			assert.equal( $res.find( 'b' ).text(), 'Hello world', 'Bold tag wraps the entire, same, text' );
+
+			QUnit.start();
+		});
+});
diff --git a/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js b/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js
new file mode 100644
index 00000000..79bd7306
--- /dev/null
+++ b/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js
@@ -0,0 +1,59 @@
+QUnit.module( 'mediawiki.api', QUnit.newMwEnvironment() );
+
+QUnit.asyncTest( 'Basic functionality', function ( assert ) {
+	var api, d1, d2, d3;
+	QUnit.expect( 3 );
+
+	api = new mw.Api();
+
+	d1 = api.get( {} )
+		.done( function ( data ) {
+			assert.deepEqual( data, [], 'If request succeeds without errors, resolve deferred' );
+		});
+
+	d2 = api.get({
+			action: 'doesntexist'
+		})
+		.fail( function ( errorCode, details ) {
+			assert.equal( errorCode, 'unknown_action', 'API error (e.g. "unknown_action") should reject the deferred' );
+		});
+
+	d3 = api.post( {} )
+		.done( function ( data ) {
+			assert.deepEqual( data, [], 'Simple POST request' );
+		});
+
+	// After all are completed, continue the test suite.
+	QUnit.whenPromisesComplete( d1, d2, d3 ).always( function () {
+		QUnit.start();
+	});
+});
+
+QUnit.asyncTest( 'Deprecated callback methods', function ( assert ) {
+	var api, d1, d2, d3;
+	QUnit.expect( 3 );
+
+	api = new mw.Api();
+
+	d1 = api.get( {}, function () {
+		assert.ok( true, 'Function argument treated as success callback.' );
+	});
+
+	d2 = api.get( {}, {
+		ok: function ( data ) {
+			assert.ok( true, '"ok" property treated as success callback.' );
+		}
+	});
+
+	d3 = api.get({
+			action: 'doesntexist'
+		}, {
+		err: function ( data ) {
+			assert.ok( true, '"err" property treated as error callback.' );
+		}
+	});
+
+	QUnit.whenPromisesComplete( d1, d2, d3 ).always( function () {
+		QUnit.start();
+	});
+});
diff --git a/tests/qunit/suites/resources/mediawiki.special/mediawiki.special.recentchanges.test.js b/tests/qunit/suites/resources/mediawiki.special/mediawiki.special.recentchanges.test.js
index d73fe5a6..7fe7baf8 100644
--- a/tests/qunit/suites/resources/mediawiki.special/mediawiki.special.recentchanges.test.js
+++ b/tests/qunit/suites/resources/mediawiki.special/mediawiki.special.recentchanges.test.js
@@ -1,13 +1,8 @@
-module( 'mediawiki.special.recentchanges', QUnit.newMwEnvironment() );
+QUnit.module( 'mediawiki.special.recentchanges', QUnit.newMwEnvironment() );
 
-test( '-- Initial check', function() {
-	expect( 2 );
-	ok( mw.special.recentchanges.init, 'mw.special.recentchanges.init defined' );
-	ok( mw.special.recentchanges.updateCheckboxes, 'mw.special.recentchanges.updateCheckboxes defined' );
-	// TODO: verify checkboxes == [ 'nsassociated', 'nsinvert' ]
-});
+// TODO: verify checkboxes == [ 'nsassociated', 'nsinvert' ]
 
-test( '"all" namespace disable checkboxes', function() {
+QUnit.test( '"all" namespace disable checkboxes', function ( assert ) {
 
 	// from Special:Recentchanges
 	var select =
@@ -33,15 +28,15 @@ test( '"all" namespace disable checkboxes', function() {
 	// TODO abstract the double strictEquals
 
 	// At first checkboxes are enabled
-	strictEqual( $( '#nsinvert' ).prop( 'disabled' ), false );
-	strictEqual( $( '#nsassociated' ).prop( 'disabled' ), false );
+	assert.strictEqual( $( '#nsinvert' ).prop( 'disabled' ), false );
+	assert.strictEqual( $( '#nsassociated' ).prop( 'disabled' ), false );
 
 	// Initiate the recentchanges module
 	mw.special.recentchanges.init();
 
 	// By default
-	strictEqual( $( '#nsinvert' ).prop( 'disabled' ), true );
-	strictEqual( $( '#nsassociated' ).prop( 'disabled' ), true );
+	assert.strictEqual( $( '#nsinvert' ).prop( 'disabled' ), true );
+	assert.strictEqual( $( '#nsassociated' ).prop( 'disabled' ), true );
 
 	// select second option...
 	var $options = $( '#namespace' ).find( 'option' );
@@ -50,8 +45,8 @@ test( '"all" namespace disable checkboxes', function() {
 	$( '#namespace' ).change();
 
 	// ... and checkboxes should be enabled again
-	strictEqual( $( '#nsinvert' ).prop( 'disabled' ), false );
-	strictEqual( $( '#nsassociated' ).prop( 'disabled' ), false );
+	assert.strictEqual( $( '#nsinvert' ).prop( 'disabled' ), false );
+	assert.strictEqual( $( '#nsassociated' ).prop( 'disabled' ), false );
 
 	// select first option ( 'all' namespace)...
 	$options.eq(1).removeProp( 'selected' );
@@ -59,8 +54,8 @@ test( '"all" namespace disable checkboxes', function() {
 	$( '#namespace' ).change();
 
 	// ... and checkboxes should now be disabled
-	strictEqual( $( '#nsinvert' ).prop( 'disabled' ), true );
-	strictEqual( $( '#nsassociated' ).prop( 'disabled' ), true );
+	assert.strictEqual( $( '#nsinvert' ).prop( 'disabled' ), true );
+	assert.strictEqual( $( '#nsassociated' ).prop( 'disabled' ), true );
 
 	// DOM cleanup
 	$env.remove();
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.Title.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.Title.test.js
index e04111f1..a736e121 100644
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.Title.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.Title.test.js
@@ -55,147 +55,146 @@ var config = {
 	"wgCaseSensitiveNamespaces": []
 };
 
-module( 'mediawiki.Title', QUnit.newMwEnvironment( config ) );
+QUnit.module( 'mediawiki.Title', QUnit.newMwEnvironment({ config: config }) );
 
-test( '-- Initial check', function () {
-	expect(1);
-	ok( mw.Title, 'mw.Title defined' );
-});
-
-test( 'Transformation', function () {
-	expect(8);
 
+QUnit.test( 'Transformation', 8, function ( assert ) {
 	var title;
 
 	title = new mw.Title( 'File:quux pif.jpg' );
-	equal( title.getName(), 'Quux_pif' );
+	assert.equal( title.getName(), 'Quux_pif' );
 
 	title = new mw.Title( 'File:Glarg_foo_glang.jpg' );
-	equal( title.getNameText(), 'Glarg foo glang' );
+	assert.equal( title.getNameText(), 'Glarg foo glang' );
 
 	title = new mw.Title( 'User:ABC.DEF' );
-	equal( title.toText(), 'User:ABC.DEF' );
-	equal( title.getNamespaceId(), 2 );
-	equal( title.getNamespacePrefix(), 'User:' );
+	assert.equal( title.toText(), 'User:ABC.DEF' );
+	assert.equal( title.getNamespaceId(), 2 );
+	assert.equal( title.getNamespacePrefix(), 'User:' );
 
 	title = new mw.Title( 'uSEr:hAshAr' );
-	equal( title.toText(), 'User:HAshAr' );
-	equal( title.getNamespaceId(), 2 );
+	assert.equal( title.toText(), 'User:HAshAr' );
+	assert.equal( title.getNamespaceId(), 2 );
 
 	title = new mw.Title( '   MediaWiki:  Foo   bar   .js   ' );
 	// Don't ask why, it's the way the backend works. One space is kept of each set
-	equal( title.getName(), 'Foo_bar_.js', "Merge multiple spaces to a single space." );
+	assert.equal( title.getName(), 'Foo_bar_.js', "Merge multiple spaces to a single space." );
 });
 
-test( 'Main text for filename', function () {
-	expect(8);
-
+QUnit.test( 'Main text for filename', 8, function ( assert ) {
 	var title = new mw.Title( 'File:foo_bar.JPG' );
 
-	equal( title.getNamespaceId(), 6 );
-	equal( title.getNamespacePrefix(), 'File:' );
-	equal( title.getName(), 'Foo_bar' );
-	equal( title.getNameText(), 'Foo bar' );
-	equal( title.getMain(), 'Foo_bar.JPG' );
-	equal( title.getMainText(), 'Foo bar.JPG' );
-	equal( title.getExtension(), 'JPG' );
-	equal( title.getDotExtension(), '.JPG' );
+	assert.equal( title.getNamespaceId(), 6 );
+	assert.equal( title.getNamespacePrefix(), 'File:' );
+	assert.equal( title.getName(), 'Foo_bar' );
+	assert.equal( title.getNameText(), 'Foo bar' );
+	assert.equal( title.getMain(), 'Foo_bar.JPG' );
+	assert.equal( title.getMainText(), 'Foo bar.JPG' );
+	assert.equal( title.getExtension(), 'JPG' );
+	assert.equal( title.getDotExtension(), '.JPG' );
 });
 
-test( 'Namespace detection and conversion', function () {
-	expect(6);
-
+QUnit.test( 'Namespace detection and conversion', 6, function ( assert ) {
 	var title;
 
 	title = new mw.Title( 'something.PDF', 6 );
-	equal( title.toString(), 'File:Something.PDF' );
+	assert.equal( title.toString(), 'File:Something.PDF' );
 
 	title = new mw.Title( 'NeilK', 3 );
-	equal( title.toString(), 'User_talk:NeilK' );
-	equal( title.toText(), 'User talk:NeilK' );
+	assert.equal( title.toString(), 'User_talk:NeilK' );
+	assert.equal( title.toText(), 'User talk:NeilK' );
 
 	title = new mw.Title( 'Frobisher', 100 );
-	equal( title.toString(), 'Penguins:Frobisher' );
+	assert.equal( title.toString(), 'Penguins:Frobisher' );
 
 	title = new mw.Title( 'antarctic_waterfowl:flightless_yet_cute.jpg' );
-	equal( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
+	assert.equal( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
 
 	title = new mw.Title( 'Penguins:flightless_yet_cute.jpg' );
-	equal( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
+	assert.equal( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
 });
 
-test( 'Throw error on invalid title', function () {
-	expect(1);
-
-	raises(function () {
+QUnit.test( 'Throw error on invalid title', 1, function ( assert ) {
+	assert.throws(function () {
 		var title = new mw.Title( '' );
 	}, 'Throw error on empty string' );
 });
 
-test( 'Case-sensivity', function () {
-	expect(3);
-
+QUnit.test( 'Case-sensivity', 3, function ( assert ) {
 	var title;
 
 	// Default config
 	mw.config.set( 'wgCaseSensitiveNamespaces', [] );
 
 	title = new mw.Title( 'article' );
-	equal( title.toString(), 'Article', 'Default config: No sensitive namespaces by default. First-letter becomes uppercase' );
+	assert.equal( title.toString(), 'Article', 'Default config: No sensitive namespaces by default. First-letter becomes uppercase' );
 
 	// $wgCapitalLinks = false;
 	mw.config.set( 'wgCaseSensitiveNamespaces', [0, -2, 1, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15] );
 
 	title = new mw.Title( 'article' );
-	equal( title.toString(), 'article', '$wgCapitalLinks=false: Article namespace is sensitive, first-letter case stays lowercase' );
+	assert.equal( title.toString(), 'article', '$wgCapitalLinks=false: Article namespace is sensitive, first-letter case stays lowercase' );
 
 	title = new mw.Title( 'john', 2 );
-	equal( title.toString(), 'User:John', '$wgCapitalLinks=false: User namespace is insensitive, first-letter becomes uppercase' );
+	assert.equal( title.toString(), 'User:John', '$wgCapitalLinks=false: User namespace is insensitive, first-letter becomes uppercase' );
 });
 
-test( 'toString / toText', function () {
-	expect(2);
-
+QUnit.test( 'toString / toText', 2, function ( assert ) {
 	var title = new mw.Title( 'Some random page' );
 
-	equal( title.toString(), title.getPrefixedDb() );
-	equal( title.toText(), title.getPrefixedText() );
+	assert.equal( title.toString(), title.getPrefixedDb() );
+	assert.equal( title.toText(), title.getPrefixedText() );
 });
 
-test( 'Exists', function () {
-	expect(3);
+QUnit.test( 'getExtension', 7, function ( assert ) {
+
+	function extTest( pagename, ext, description ) {
+		var title = new mw.Title( pagename );
+		assert.equal( title.getExtension(), ext, description || pagename );
+	}
+
+	extTest( 'MediaWiki:Vector.js', 'js' );
+	extTest( 'User:Example/common.css', 'css' );
+	extTest( 'File:Example.longextension', 'longextension', 'Extension parsing not limited (bug 36151)' );
+	extTest( 'Example/information.json', 'json', 'Extension parsing not restricted from any namespace' );
+	extTest( 'Foo.', null, 'Trailing dot is not an extension' );
+	extTest( 'Foo..', null, 'Trailing dots are not an extension' );
+	extTest( 'Foo.a.', null, 'Page name with dots and ending in a dot does not have an extension' );
 
+	// @broken: Throws an exception
+	// extTest( '.NET', null, 'Leading dot is (or is not?) an extension' );
+});
+
+QUnit.test( 'exists', 3, function ( assert ) {
 	var title;
 
 	// Empty registry, checks default to null
 
 	title = new mw.Title( 'Some random page', 4 );
-	strictEqual( title.exists(), null, 'Return null with empty existance registry' );
+	assert.strictEqual( title.exists(), null, 'Return null with empty existance registry' );
 
 	// Basic registry, checks default to boolean
 	mw.Title.exist.set( ['Does_exist', 'User_talk:NeilK', 'Wikipedia:Sandbox_rules'], true );
 	mw.Title.exist.set( ['Does_not_exist', 'User:John', 'Foobar'], false );
 
 	title = new mw.Title( 'Project:Sandbox rules' );
-	assertTrue( title.exists(), 'Return true for page titles marked as existing' );
+	assert.assertTrue( title.exists(), 'Return true for page titles marked as existing' );
 	title = new mw.Title( 'Foobar' );
-	assertFalse( title.exists(), 'Return false for page titles marked as nonexistent' );
+	assert.assertFalse( title.exists(), 'Return false for page titles marked as nonexistent' );
 
 });
 
-test( 'Url', function () {
-	expect(2);
-
+QUnit.test( 'getUrl', 2, function ( assert ) {
 	var title;
 
 	// Config
 	mw.config.set( 'wgArticlePath', '/wiki/$1' );
 
 	title = new mw.Title( 'Foobar' );
-	equal( title.getUrl(), '/wiki/Foobar', 'Basic functionally, toString passing to wikiGetlink' );
+	assert.equal( title.getUrl(), '/wiki/Foobar', 'Basic functionally, toString passing to wikiGetlink' );
 
 	title = new mw.Title( 'John Doe', 3 );
-	equal( title.getUrl(), '/wiki/User_talk:John_Doe', 'Escaping in title and namespace for urls' );
+	assert.equal( title.getUrl(), '/wiki/User_talk:John_Doe', 'Escaping in title and namespace for urls' );
 });
 
 }() );
\ No newline at end of file
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.Uri.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.Uri.test.js
new file mode 100644
index 00000000..68a9eafb
--- /dev/null
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.Uri.test.js
@@ -0,0 +1,388 @@
+QUnit.module( 'mediawiki.Uri', QUnit.newMwEnvironment({
+	setup: function () {
+		this.mwUriOrg = mw.Uri;
+		mw.Uri = mw.UriRelative( 'http://example.org/w/index.php' );
+	},
+	teardown: function () {
+		mw.Uri = this.mwUriOrg;
+		delete this.mwUriOrg;
+	}
+}) );
+
+$.each( [true, false], function ( i, strictMode ) {
+	QUnit.test( 'Basic mw.Uri object test in ' + ( strictMode ? '' : 'non-' ) + 'strict mode for a simple HTTP URI', 2, function ( assert ) {
+		var uriString, uri;
+		uriString = 'http://www.ietf.org/rfc/rfc2396.txt';
+		uri = new mw.Uri( uriString, {
+			strictMode: strictMode
+		});
+
+		assert.deepEqual(
+			{
+				protocol: uri.protocol,
+				host: uri.host,
+				port: uri.port,
+				path: uri.path,
+				query: uri.query,
+				fragment: uri.fragment
+			}, {
+				protocol: 'http',
+				host: 'www.ietf.org',
+				port: undefined,
+				path: '/rfc/rfc2396.txt',
+				query: {},
+				fragment: undefined
+			},
+			'basic object properties'
+		);
+
+		assert.deepEqual(
+			{
+				userInfo: uri.getUserInfo(),
+				authority: uri.getAuthority(),
+				hostPort: uri.getHostPort(),
+				queryString: uri.getQueryString(),
+				relativePath: uri.getRelativePath(),
+				toString: uri.toString()
+			},
+			{
+				userInfo: '',
+				authority: 'www.ietf.org',
+				hostPort: 'www.ietf.org',
+				queryString: '',
+				relativePath: '/rfc/rfc2396.txt',
+				toString: uriString
+			},
+			'construct composite components of URI on request'
+		);
+
+	});
+});
+
+QUnit.test( 'Parse an ftp URI correctly with user and password', 1, function ( assert ) {
+	var uri = new mw.Uri( 'ftp://usr:pwd@192.0.2.16/' );
+
+	assert.deepEqual(
+		{
+			protocol: uri.protocol,
+			user: uri.user,
+			password: uri.password,
+			host: uri.host,
+			port: uri.port,
+			path: uri.path,
+			query: uri.query,
+			fragment: uri.fragment
+		},
+		{
+			protocol: 'ftp',
+			user: 'usr',
+			password: 'pwd',
+			host: '192.0.2.16',
+			port: undefined,
+			path: '/',
+			query: {},
+			fragment: undefined
+		},
+		'basic object properties'
+	);
+} );
+
+QUnit.test( 'Parse a uri with simple querystring', 1, function ( assert ) {
+	var uri = new mw.Uri( 'http://www.google.com/?q=uri' );
+
+	assert.deepEqual(
+		{
+			protocol: uri.protocol,
+			host: uri.host,
+			port: uri.port,
+			path: uri.path,
+			query: uri.query,
+			fragment: uri.fragment,
+			queryString: uri.getQueryString()
+		},
+		{
+			protocol: 'http',
+			host: 'www.google.com',
+			port: undefined,
+			path: '/',
+			query: { q: 'uri' },
+			fragment: undefined,
+			queryString: 'q=uri'
+		},
+		'basic object properties'
+	);
+} );
+
+QUnit.test( 'Handle multiple query parameter (overrideKeys on)', 5, function ( assert ) {
+	var uri = new mw.Uri( 'http://www.example.com/dir/?m=foo&m=bar&n=1', {
+		overrideKeys: true
+	});
+
+	assert.equal( uri.query.n, '1', 'multiple parameters are parsed' );
+	assert.equal( uri.query.m, 'bar', 'last key overrides earlier keys' );
+
+	uri.query.n = [ 'x', 'y', 'z' ];
+
+	// Verify parts and total length instead of entire string because order
+	// of iteration can vary.
+	assert.ok( uri.toString().indexOf( 'm=bar' ), 'toString preserves other values' );
+	assert.ok( uri.toString().indexOf( 'n=x&n=y&n=z' ), 'toString parameter includes all values of an array query parameter' );
+	assert.equal( uri.toString().length, 'http://www.example.com/dir/?m=bar&n=x&n=y&n=z'.length, 'toString matches expected string' );
+} );
+
+QUnit.test( 'Handle multiple query parameter (overrideKeys off)', 9, function ( assert ) {
+	var uri = new mw.Uri( 'http://www.example.com/dir/?m=foo&m=bar&n=1', {
+		overrideKeys: false
+	});
+
+	// Strict comparison so that types are also verified (n should be string '1')
+	assert.strictEqual( uri.query.m.length, 2, 'multi-value query should be an array with 2 items' );
+	assert.strictEqual( uri.query.m[0], 'foo', 'order and value is correct' );
+	assert.strictEqual( uri.query.m[1], 'bar', 'order and value is correct' );
+	assert.strictEqual( uri.query.n, '1', 'n=1 is parsed with the correct value of the expected type' );
+
+	// Change query values
+	uri.query.n = [ 'x', 'y', 'z' ];
+
+	// Verify parts and total length instead of entire string because order
+	// of iteration can vary.
+	assert.ok( uri.toString().indexOf( 'm=foo&m=bar' ) >= 0, 'toString preserves other values' );
+	assert.ok( uri.toString().indexOf( 'n=x&n=y&n=z' ) >= 0, 'toString parameter includes all values of an array query parameter' );
+	assert.equal( uri.toString().length, 'http://www.example.com/dir/?m=foo&m=bar&n=x&n=y&n=z'.length, 'toString matches expected string' );
+
+	// Remove query values
+	uri.query.m.splice( 0, 1 );
+	delete uri.query.n;
+
+	assert.equal( uri.toString(), 'http://www.example.com/dir/?m=bar', 'deletion properties' );
+
+	// Remove more query values, leaving an empty array
+	uri.query.m.splice( 0, 1 );
+	assert.equal( uri.toString(), 'http://www.example.com/dir/', 'empty array value is ommitted' );
+} );
+
+QUnit.test( 'All-dressed URI with everything', 11, function ( assert ) {
+	var uri, queryString, relativePath;
+
+	uri = new mw.Uri( 'http://auth@www.example.com:81/dir/dir.2/index.htm?q1=0&&test1&test2=value+%28escaped%29#top' );
+
+	assert.deepEqual(
+		{
+			protocol: uri.protocol,
+			user: uri.user,
+			password: uri.password,
+			host: uri.host,
+			port: uri.port,
+			path: uri.path,
+			query: uri.query,
+			fragment: uri.fragment
+		},
+		{
+			protocol: 'http',
+			user: 'auth',
+			password: undefined,
+			host: 'www.example.com',
+			port: '81',
+			path: '/dir/dir.2/index.htm',
+			query: { q1: '0', test1: null, test2: 'value (escaped)' },
+			fragment: 'top'
+		},
+		'basic object properties'
+	);
+
+	assert.equal( uri.getUserInfo(), 'auth', 'user info' );
+
+	assert.equal( uri.getAuthority(), 'auth@www.example.com:81', 'authority equal to auth@hostport' );
+
+	assert.equal( uri.getHostPort(), 'www.example.com:81', 'hostport equal to host:port' );
+
+	queryString = uri.getQueryString();
+	assert.ok( queryString.indexOf( 'q1=0' ) >= 0, 'query param with numbers' );
+	assert.ok( queryString.indexOf( 'test1' ) >= 0, 'query param with null value is included' );
+	assert.ok( queryString.indexOf( 'test1=' ) === -1, 'query param with null value does not generate equals sign' );
+	assert.ok( queryString.indexOf( 'test2=value+%28escaped%29' ) >= 0, 'query param is url escaped' );
+
+	relativePath = uri.getRelativePath();
+	assert.ok( relativePath.indexOf( uri.path ) >= 0, 'path in relative path' );
+	assert.ok( relativePath.indexOf( uri.getQueryString() ) >= 0, 'query string in relative path' );
+	assert.ok( relativePath.indexOf( uri.fragment ) >= 0, 'fragement in relative path' );
+} );
+
+QUnit.test( 'Cloning', 6, function ( assert ) {
+	var original, clone;
+
+	original = new mw.Uri( 'http://foo.example.org/index.php?one=1&two=2' );
+	clone = original.clone();
+
+	assert.deepEqual( clone, original, 'clone has equivalent properties' );
+	assert.equal( original.toString(), clone.toString(), 'toString matches original' );
+
+	assert.notStrictEqual( clone, original, 'clone is a different object when compared by reference' );
+
+	clone.host = 'bar.example.org';
+	assert.notEqual( original.host, clone.host, 'manipulating clone did not effect original' );
+	assert.notEqual( original.toString(), clone.toString(), 'Stringified url no longer matches original' );
+
+	clone.query.three = 3;
+
+	assert.deepEqual(
+		original.query,
+		{ 'one': '1', 'two': '2' },
+		'Properties is deep cloned (bug 37708)'
+	);
+} );
+
+QUnit.test( 'Constructing mw.Uri from plain object', 3, function ( assert ) {
+	var uri = new mw.Uri({
+		protocol: 'http',
+		host: 'www.foo.local',
+		path: '/this'
+	});
+	assert.equal( uri.toString(), 'http://www.foo.local/this', 'Basic properties' );
+
+	uri = new mw.Uri({
+		protocol: 'http',
+		host: 'www.foo.local',
+		path: '/this',
+		query: { hi: 'there' },
+		fragment: 'blah'
+	});
+	assert.equal( uri.toString(), 'http://www.foo.local/this?hi=there#blah', 'More complex properties' );
+
+	assert.throws(
+		function () {
+			var uri = new mw.Uri({
+				protocol: 'http',
+				host: 'www.foo.local'
+			});
+		},
+		function ( e ) {
+			return e.message === 'Bad constructor arguments';
+		},
+		'Construction failed when missing required properties'
+	);
+} );
+
+QUnit.test( 'Manipulate properties', 8, function ( assert ) {
+	var uriBase, uri;
+
+	uriBase = new mw.Uri( 'http://en.wiki.local/w/api.php' );
+
+	uri = uriBase.clone();
+	uri.fragment = 'frag';
+	assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php#frag', 'add a fragment' );
+
+	uri = uriBase.clone();
+	uri.host = 'fr.wiki.local';
+	uri.port = '8080';
+	assert.equal( uri.toString(), 'http://fr.wiki.local:8080/w/api.php', 'change host and port' );
+
+	uri = uriBase.clone();
+	uri.query.foo = 'bar';
+	assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php?foo=bar', 'add query arguments' );
+
+	delete uri.query.foo;
+	assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php', 'delete query arguments' );
+
+	uri = uriBase.clone();
+	uri.query.foo = 'bar';
+	assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php?foo=bar', 'extend query arguments' );
+	uri.extend({
+		foo: 'quux',
+		pif: 'paf'
+	});
+	assert.ok( uri.toString().indexOf( 'foo=quux' ) >= 0, 'extend query arguments' );
+	assert.ok( uri.toString().indexOf( 'foo=bar' ) === -1, 'extend query arguments' );
+	assert.ok( uri.toString().indexOf( 'pif=paf' ) >= 0 , 'extend query arguments' );
+} );
+
+QUnit.test( 'Handle protocol-relative URLs', 5, function ( assert ) {
+	var UriRel, uri;
+
+	UriRel = mw.UriRelative( 'glork://en.wiki.local/foo.php' );
+
+	uri = new UriRel( '//en.wiki.local/w/api.php' );
+	assert.equal( uri.protocol, 'glork', 'create protocol-relative URLs with same protocol as document' );
+
+	uri = new UriRel( '/foo.com' );
+	assert.equal( uri.toString(), 'glork://en.wiki.local/foo.com', 'handle absolute paths by supplying protocol and host from document in loose mode' );
+
+	uri = new UriRel( 'http:/foo.com' );
+	assert.equal( uri.toString(), 'http://en.wiki.local/foo.com', 'handle absolute paths by supplying host from document in loose mode' );
+
+	uri = new UriRel( '/foo.com', true );
+	assert.equal( uri.toString(), 'glork://en.wiki.local/foo.com', 'handle absolute paths by supplying protocol and host from document in strict mode' );
+
+	uri = new UriRel( 'http:/foo.com', true );
+	assert.equal( uri.toString(), 'http://en.wiki.local/foo.com', 'handle absolute paths by supplying host from document in strict mode' );
+} );
+
+QUnit.test( 'Bad calls', 3, function ( assert ) {
+	var uri;
+
+	assert.throws(
+		function () {
+			return new mw.Uri( 'glaswegian penguins' );
+		},
+		function ( e ) {
+			return e.message === 'Bad constructor arguments';
+		},
+		'throw error on non-URI as argument to constructor'
+	);
+
+	assert.throws(
+		function () {
+			return new mw.Uri( 'foo.com/bar/baz', {
+				strictMode: true
+			});
+		},
+		function ( e ) {
+			return e.message === 'Bad constructor arguments';
+		},
+		'throw error on URI without protocol or // or leading / in strict mode'
+	);
+
+	uri = new mw.Uri( 'foo.com/bar/baz', {
+		strictMode: false
+	});
+	assert.equal( uri.toString(), 'http://foo.com/bar/baz', 'normalize URI without protocol or // in loose mode' );
+});
+
+QUnit.test( 'bug 35658', 2, function ( assert ) {
+	var testProtocol, testServer, testPort, testPath, UriClass, uri, href;
+
+	testProtocol = 'https://';
+	testServer = 'foo.example.org';
+	testPort = '3004';
+	testPath = '/!1qy';
+
+	UriClass = mw.UriRelative( testProtocol + testServer + '/some/path/index.html' );
+	uri = new UriClass( testPath );
+	href = uri.toString();
+	assert.equal( href, testProtocol + testServer + testPath, 'Root-relative URL gets host & protocol supplied' );
+
+	UriClass = mw.UriRelative( testProtocol + testServer + ':' + testPort + '/some/path.php' );
+	uri = new UriClass( testPath );
+	href = uri.toString();
+	assert.equal( href, testProtocol + testServer + ':' + testPort + testPath, 'Root-relative URL gets host, protocol, and port supplied' );
+
+} );
+
+QUnit.test( 'Constructor falls back to default location', 4, function ( assert ) {
+	var testuri, MyUri, uri;
+
+	testuri = 'http://example.org/w/index.php';
+	MyUri = mw.UriRelative( testuri );
+
+	uri = new MyUri();
+	assert.equal( uri.toString(), testuri, 'no arguments' );
+
+	uri = new MyUri( undefined );
+	assert.equal( uri.toString(), testuri, 'undefined' );
+
+	uri = new MyUri( null );
+	assert.equal( uri.toString(), testuri, 'null' );
+
+	uri = new MyUri( '' );
+	assert.equal( uri.toString(), testuri, 'empty string' );
+} );
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.cldr.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.cldr.test.js
new file mode 100644
index 00000000..e2c66685
--- /dev/null
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.cldr.test.js
@@ -0,0 +1,74 @@
+QUnit.module( 'mediawiki.cldr', QUnit.newMwEnvironment() );
+
+var pluralTestcases = {
+	/*
+	 * Sample:
+	 * "languagecode" : [
+	 *   [ number, [ "form1", "form2", ... ],  "expected", "description" ]
+	 * ];
+	 */
+	"en": [
+		[ 0, [ "one", "other" ], "other", "English plural test- 0 is other" ],
+		[ 1, [ "one", "other" ], "one", "English plural test- 1 is one" ]
+	],
+	"fa": [
+		[ 0, [ "one", "other" ], "other", "Persian plural test- 0 is other" ],
+		[ 1, [ "one", "other" ], "one", "Persian plural test- 1 is one" ],
+		[ 2, [ "one", "other" ], "other", "Persian plural test- 2 is other" ]
+	],
+	"fr": [
+		[ 0, [ "one", "other" ], "other", "French plural test- 0 is other" ],
+		[ 1, [ "one", "other" ], "one", "French plural test- 1 is one" ]
+	],
+	"hi": [
+		[ 0, [ "one", "other" ], "one", "Hindi plural test- 0 is one" ],
+		[ 1, [ "one", "other" ], "one", "Hindi plural test- 1 is one" ],
+		[ 2, [ "one", "other" ], "other", "Hindi plural test- 2 is other" ]
+	],
+	"he": [
+		[ 0, [ "one", "other" ], "other", "Hebrew plural test- 0 is other" ],
+		[ 1, [ "one", "other" ], "one", "Hebrew plural test- 1 is one" ],
+		[ 2, [ "one", "other" ], "other", "Hebrew plural test- 2 is other with 2 forms" ],
+		[ 2, [ "one", "dual", "other" ], "dual", "Hebrew plural test- 2 is dual with 3 forms" ]
+	],
+	"hu": [
+		[ 0, [ "one", "other" ], "other", "Hungarian plural test- 0 is other" ],
+		[ 1, [ "one", "other" ], "one", "Hungarian plural test- 1 is one" ],
+		[ 2, [ "one", "other" ], "other", "Hungarian plural test- 2 is other" ]
+	],
+	"ar": [
+		[ 0, [ "zero", "one", "two", "few", "many", "other" ], "zero", "Arabic plural test - 0 is zero" ],
+		[ 1, [ "zero", "one", "two", "few", "many", "other" ], "one", "Arabic plural test - 1 is one" ],
+		[ 2, [ "zero", "one", "two", "few", "many", "other" ], "two", "Arabic plural test - 2 is two" ],
+		[ 3, [ "zero", "one", "two", "few", "many", "other" ], "few", "Arabic plural test - 3 is few" ],
+		[ 9, [ "zero", "one", "two", "few", "many", "other" ], "few", "Arabic plural test - 9 is few" ],
+		[ "9", [ "zero", "one", "two", "few", "many", "other" ], "few", "Arabic plural test - 9 is few" ],
+		[ 110, [ "zero", "one", "two", "few", "many", "other" ], "few", "Arabic plural test - 110 is few" ],
+		[ 11, [ "zero", "one", "two", "few", "many", "other" ], "many", "Arabic plural test - 11 is many" ],
+		[ 15, [ "zero", "one", "two", "few", "many", "other" ], "many", "Arabic plural test - 15 is many" ],
+		[ 99, [ "zero", "one", "two", "few", "many", "other" ], "many", "Arabic plural test - 99 is many" ],
+		[ 9999, [ "zero", "one", "two", "few", "many", "other" ], "many", "Arabic plural test - 9999 is many" ],
+		[ 100, [ "zero", "one", "two", "few", "many", "other" ], "other", "Arabic plural test - 100 is other" ],
+		[ 102, [ "zero", "one", "two", "few", "many", "other" ], "other", "Arabic plural test - 102 is other" ],
+		[ 1000, [ "zero", "one", "two", "few", "many", "other" ], "other", "Arabic plural test - 1000 is other" ],
+		[ 1.7, [ "zero", "one", "two", "few", "many", "other" ], "other", "Arabic plural test - 1.7 is other" ]
+	]
+};
+
+function pluralTest( langCode, tests ) {
+	QUnit.test( 'Plural Test for ' + langCode, tests.length, function ( assert ) {
+		for ( var i = 0; i < tests.length; i++ ) {
+			assert.equal(
+				mw.language.convertPlural( tests[i][0], tests[i][1] ),
+				tests[i][2],
+				tests[i][3]
+			);
+		}
+	} );
+}
+
+$.each( pluralTestcases, function ( langCode, tests ) {
+	if ( langCode === mw.config.get( 'wgUserLanguage' ) ) {
+		pluralTest( langCode, tests );
+	}
+} );
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.jqueryMsg.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.jqueryMsg.test.js
index 265ec2ae..b8193a92 100644
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.jqueryMsg.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.jqueryMsg.test.js
@@ -1,43 +1,97 @@
-module( 'mediawiki.jqueryMsg' );
+QUnit.module( 'mediawiki.jqueryMsg' );
 
-test( '-- Initial check', function() {
-	expect( 1 );
-	ok( mw.jqueryMsg, 'mw.jqueryMsg defined' );
-} );
-
-test( 'mw.jqueryMsg Plural', function() {
-	expect( 5 );
+QUnit.test( 'mw.jqueryMsg Plural', 3, function ( assert ) {
 	var parser = mw.jqueryMsg.getMessageFunction();
-	ok( parser, 'Parser Function initialized' );
-	ok( mw.messages.set( 'plural-msg', 'Found $1 {{PLURAL:$1|item|items}}' ), 'mw.messages.set: Register' );
-	equal( parser( 'plural-msg', 0 ) , 'Found 0 items', 'Plural test for english with zero as count' );
-	equal( parser( 'plural-msg', 1 ) , 'Found 1 item', 'Singular test for english' );
-	equal( parser( 'plural-msg', 2 ) , 'Found 2 items', 'Plural test for english' );
+
+	mw.messages.set( 'plural-msg', 'Found $1 {{PLURAL:$1|item|items}}' );
+	assert.equal( parser( 'plural-msg', 0 ), 'Found 0 items', 'Plural test for english with zero as count' );
+	assert.equal( parser( 'plural-msg', 1 ), 'Found 1 item', 'Singular test for english' );
+	assert.equal( parser( 'plural-msg', 2 ), 'Found 2 items', 'Plural test for english' );
 } );
 
 
-test( 'mw.jqueryMsg Gender', function() {
-	expect( 16 );
-	//TODO: These tests should be for mw.msg once mw.msg integrated with mw.jqueryMsg
-	var user = mw.user;
+QUnit.test( 'mw.jqueryMsg Gender', 11, function ( assert ) {
+	// TODO: These tests should be for mw.msg once mw.msg integrated with mw.jqueryMsg
+	// TODO: English may not be the best language for these tests. Use a language like Arabic or Russian
+	var user = mw.user,
+		parser = mw.jqueryMsg.getMessageFunction();
+
+	// The values here are not significant,
+	// what matters is which of the values is choosen by the parser
+	mw.messages.set( 'gender-msg', '$1: {{GENDER:$2|blue|pink|green}}' );
+
 	user.options.set( 'gender', 'male' );
-	var parser = mw.jqueryMsg.getMessageFunction();
-	ok( parser, 'Parser Function initialized' );
-	//TODO: English may not be the best language for these tests. Use a language like Arabic or Russian
-	ok( mw.messages.set( 'gender-msg', '$1 reverted {{GENDER:$2|his|her|their}} last edit' ), 'mw.messages.set: Register' );
-	equal( parser( 'gender-msg', 'Bob', 'male' ) , 'Bob reverted his last edit', 'Gender masculine' );
-	equal( parser( 'gender-msg', 'Bob', user ) , 'Bob reverted his last edit', 'Gender masculine' );
+	assert.equal(
+		parser( 'gender-msg', 'Bob', 'male' ),
+		'Bob: blue',
+		'Masculine from string "male"'
+	);
+	assert.equal(
+		parser( 'gender-msg', 'Bob', user ),
+		'Bob: blue',
+		'Masculine from mw.user object'
+	);
+
 	user.options.set( 'gender', 'unknown' );
-	equal( parser( 'gender-msg', 'They', user ) , 'They reverted their last edit', 'Gender neutral or unknown' );
-	equal( parser( 'gender-msg', 'Alice', 'female' ) , 'Alice reverted her last edit', 'Gender feminine' );
-	equal( parser( 'gender-msg', 'User' ) , 'User reverted their last edit', 'Gender neutral' );
-	equal( parser( 'gender-msg', 'User', 'unknown' ) , 'User reverted their last edit', 'Gender neutral' );
-	ok( mw.messages.set( 'gender-msg-one-form', '{{GENDER:$1|User}} reverted last $2 {{PLURAL:$2|edit|edits}}' ), 'mw.messages.set: Register' );
-	equal( parser( 'gender-msg-one-form', 'male', 10 ) , 'User reverted last 10 edits', 'Gender neutral and plural form' );
-	equal( parser( 'gender-msg-one-form', 'female', 1 ) , 'User reverted last 1 edit', 'Gender neutral and singular form' );
-	ok( mw.messages.set( 'gender-msg-lowercase', '{{gender:$1|he|she}} is awesome' ), 'mw.messages.set: Register' );
-	equal( parser( 'gender-msg-lowercase', 'male' ) , 'he is awesome', 'Gender masculine' );
-	equal( parser( 'gender-msg-lowercase', 'female' ) , 'she is awesome', 'Gender feminine' );
-	ok( mw.messages.set( 'gender-msg-wrong', '{{gender}} is awesome' ), 'mw.messages.set: Register' );
-	equal( parser( 'gender-msg-wrong', 'female' ) , ' is awesome', 'Wrong syntax used, but ignore the {{gender}}' );
+	assert.equal(
+		parser( 'gender-msg', 'Foo', user ),
+		'Foo: green',
+		'Neutral from mw.user object' );
+	assert.equal(
+		parser( 'gender-msg', 'Alice', 'female' ),
+		'Alice: pink',
+		'Feminine from string "female"' );
+	assert.equal(
+		parser( 'gender-msg', 'User' ),
+		'User: green',
+		'Neutral when no parameter given' );
+	assert.equal(
+		parser( 'gender-msg', 'User', 'unknown' ),
+		'User: green',
+		'Neutral from string "unknown"'
+	);
+
+	mw.messages.set( 'gender-msg-one-form', '{{GENDER:$1|User}}: $2 {{PLURAL:$2|edit|edits}}' );
+
+	assert.equal(
+		parser( 'gender-msg-one-form', 'male', 10 ),
+		'User: 10 edits',
+		'Gender neutral and plural form'
+	);
+	assert.equal(
+		parser( 'gender-msg-one-form', 'female', 1 ),
+		'User: 1 edit',
+		'Gender neutral and singular form'
+	);
+
+	mw.messages.set( 'gender-msg-lowercase', '{{gender:$1|he|she}} is awesome' );
+	assert.equal(
+		parser( 'gender-msg-lowercase', 'male' ),
+		'he is awesome',
+		'Gender masculine'
+	);
+	assert.equal(
+		parser( 'gender-msg-lowercase', 'female' ),
+		'she is awesome',
+		'Gender feminine'
+	);
+
+	mw.messages.set( 'gender-msg-wrong', '{{gender}} test' );
+	assert.equal(
+		parser( 'gender-msg-wrong', 'female' ),
+		' test',
+		'Invalid syntax should result in {{gender}} simply being stripped away'
+	);
+} );
+
+
+QUnit.test( 'mw.jqueryMsg Grammar', 2, function ( assert ) {
+	var parser = mw.jqueryMsg.getMessageFunction();
+
+	// Assume the grammar form grammar_case_foo is not valid in any language
+	mw.messages.set( 'grammar-msg', 'Przeszukaj {{GRAMMAR:grammar_case_foo|{{SITENAME}}}}' );
+	assert.equal( parser( 'grammar-msg' ), 'Przeszukaj ' + mw.config.get( 'wgSiteName' ), 'Grammar Test with sitename' );
+
+	mw.messages.set( 'grammar-msg-wrong-syntax', 'Przeszukaj {{GRAMMAR:grammar_case_xyz}}' );
+	assert.equal( parser( 'grammar-msg-wrong-syntax' ), 'Przeszukaj ' , 'Grammar Test with wrong grammar template syntax' );
 } );
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.jscompat.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.jscompat.test.js
index 24005b64..2baa4f37 100644
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.jscompat.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.jscompat.test.js
@@ -1,24 +1,24 @@
 /* Some misc JavaScript compatibility tests, just to make sure the environments we run in are consistent */
 
-module( 'mediawiki.jscompat', QUnit.newMwEnvironment() );
+QUnit.module( 'mediawiki.jscompat', QUnit.newMwEnvironment() );
 
-test( 'Variable with Unicode letter in name', function() {
-	expect(3);
+QUnit.test( 'Variable with Unicode letter in name', 3, function ( assert ) {
 	var orig = "some token";
 	var ŝablono = orig;
-	deepEqual( ŝablono, orig, 'ŝablono' );
-	deepEqual( \u015dablono, orig, '\\u015dablono' );
-	deepEqual( \u015Dablono, orig, '\\u015Dablono' );
+
+	assert.deepEqual( ŝablono, orig, 'ŝablono' );
+	assert.deepEqual( \u015dablono, orig, '\\u015dablono' );
+	assert.deepEqual( \u015Dablono, orig, '\\u015Dablono' );
 });
 
 /*
 // Not that we need this. ;)
 // This fails on IE 6-8
 // Works on IE 9, Firefox 6, Chrome 14
-test( 'Keyword workaround: "if" as variable name using Unicode escapes', function() {
+QUnit.test( 'Keyword workaround: "if" as variable name using Unicode escapes', function ( assert ) {
 	var orig = "another token";
 	\u0069\u0066 = orig;
-	deepEqual( \u0069\u0066, orig, '\\u0069\\u0066' );
+	assert.deepEqual( \u0069\u0066, orig, '\\u0069\\u0066' );
 });
 */
 
@@ -26,37 +26,37 @@ test( 'Keyword workaround: "if" as variable name using Unicode escapes', functio
 // Not that we need this. ;)
 // This fails on IE 6-9
 // Works on Firefox 6, Chrome 14
-test( 'Keyword workaround: "if" as member variable name using Unicode escapes', function() {
+QUnit.test( 'Keyword workaround: "if" as member variable name using Unicode escapes', function ( assert ) {
 	var orig = "another token";
 	var foo = {};
 	foo.\u0069\u0066 = orig;
-	deepEqual( foo.\u0069\u0066, orig, 'foo.\\u0069\\u0066' );
+	assert.deepEqual( foo.\u0069\u0066, orig, 'foo.\\u0069\\u0066' );
 });
 */
 
-test( 'Stripping of single initial newline from textarea\'s literal contents (bug 12130)', function() {
+QUnit.test( 'Stripping of single initial newline from textarea\'s literal contents (bug 12130)', function ( assert ) {
 	var maxn = 4;
-	expect(maxn * 2);
+	QUnit.expect( maxn * 2 );
 
-	var repeat = function(str, n) {
-		if (n <= 0) {
+	function repeat( str, n ) {
+		if ( n <= 0 ) {
 			return '';
 		} else {
-			var out = Array(n);
-			for (var i = 0; i < n; i++) {
+			var out = new Array(n);
+			for ( var i = 0; i < n; i++ ) {
 				out[i] = str;
 			}
 			return out.join('');
 		}
-	};
+	}
 
-	for (var n = 0; n < maxn; n++) {
+	for ( var n = 0; n < maxn; n++ ) {
 		var expected = repeat('\n', n) + 'some text';
 
 		var $textarea = $('<textarea>\n' + expected + '</textarea>');
-		equal($textarea.val(), expected, 'Expecting ' + n + ' newlines (HTML contained ' + (n + 1) + ')');
+		assert.equal( $textarea.val(), expected, 'Expecting ' + n + ' newlines (HTML contained ' + (n + 1) + ')' );
 
 		var $textarea2 = $('<textarea>').val(expected);
-		equal($textarea2.val(), expected, 'Expecting ' + n + ' newlines (from DOM set with ' + n + ')');
+		assert.equal( $textarea2.val(), expected, 'Expecting ' + n + ' newlines (from DOM set with ' + n + ')' );
 	}
 });
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.language.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.language.test.js
new file mode 100644
index 00000000..3fa2b099
--- /dev/null
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.language.test.js
@@ -0,0 +1,394 @@
+QUnit.module( 'mediawiki.language', QUnit.newMwEnvironment({
+	setup: function () {
+		this.liveLangData = mw.language.data.values;
+		mw.language.data.values = $.extend( true, {}, this.liveLangData );
+	},
+	teardown: function () {
+		// Restore
+		mw.language.data.values = this.liveLangData;
+	}
+}) );
+
+QUnit.test( 'mw.language getData and setData', function ( assert ) {
+	QUnit.expect( 2 );
+
+	mw.language.setData( 'en', 'testkey', 'testvalue' );
+	assert.equal(  mw.language.getData( 'en', 'testkey' ), 'testvalue', 'Getter setter test for mw.language' );
+	assert.equal(  mw.language.getData( 'en', 'invalidkey' ), undefined, 'Getter setter test for mw.language with invalid key' );
+} );
+
+function grammarTest( langCode, test ) {
+	// The test works only if the content language is opt.language
+	// because it requires [lang].js to be loaded.
+	QUnit.test( 'Grammar test for lang=' + langCode, function ( assert ) {
+		QUnit.expect( test.length );
+
+		for ( var i = 0 ; i < test.length; i++ ) {
+			assert.equal(
+				mw.language.convertGrammar( test[i].word, test[i].grammarForm ),
+				test[i].expected,
+				test[i].description
+			);
+		}
+	});
+}
+
+var grammarTests = {
+	bs: [
+		{
+			word: 'word',
+			grammarForm: 'instrumental',
+			expected: 's word',
+			description: 'Grammar test for instrumental case'
+		},
+		{
+			word: 'word',
+			grammarForm: 'lokativ',
+			expected: 'o word',
+			description: 'Grammar test for lokativ case'
+		}
+	],
+
+	he: [
+		{
+			word: "ויקיפדיה",
+			grammarForm: 'prefixed',
+			expected: "וויקיפדיה",
+			description: 'Duplicate the "Waw" if prefixed'
+		},
+		{
+			word: "וולפגנג",
+			grammarForm: 'prefixed',
+			expected: "וולפגנג",
+			description: 'Duplicate the "Waw" if prefixed, but not if it is already duplicated.'
+		},
+		{
+			word: "הקובץ",
+			grammarForm: 'prefixed',
+			expected: "קובץ",
+			description: 'Remove the "He" if prefixed'
+		},
+		{
+			word: 'Wikipedia',
+			grammarForm: 'תחילית',
+			expected: '־Wikipedia',
+			description: 'GAdd a hyphen (maqaf) before non-Hebrew letters'
+		},
+		{
+			word: '1995',
+			grammarForm: 'תחילית',
+			expected: '־1995',
+			description: 'Add a hyphen (maqaf) before numbers'
+		}
+	],
+
+	hsb: [
+		{
+			word: 'word',
+			grammarForm: 'instrumental',
+			expected: 'z word',
+			description: 'Grammar test for instrumental case'
+		},
+		{
+			word: 'word',
+			grammarForm: 'lokatiw',
+			expected: 'wo word',
+			description: 'Grammar test for lokatiw case'
+		}
+	],
+
+	dsb: [
+		{
+			word: 'word',
+			grammarForm: 'instrumental',
+			expected: 'z word',
+			description: 'Grammar test for instrumental case'
+		},
+		{
+			word: 'word',
+			grammarForm: 'lokatiw',
+			expected: 'wo word',
+			description: 'Grammar test for lokatiw case'
+		}
+	],
+
+	hy: [
+		{
+			word: 'Մաունա',
+			grammarForm: 'genitive',
+			expected: 'Մաունայի',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'հետո',
+			grammarForm: 'genitive',
+			expected: 'հետոյի',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'գիրք',
+			grammarForm: 'genitive',
+			expected: 'գրքի',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'ժամանակի',
+			grammarForm: 'genitive',
+			expected: 'ժամանակիի',
+			description: 'Grammar test for genitive case'
+		}
+	],
+
+	fi: [
+		{
+			word: 'talo',
+			grammarForm: 'genitive',
+			expected: 'talon',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'linux',
+			grammarForm: 'genitive',
+			expected: 'linuxin',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'talo',
+			grammarForm: 'elative',
+			expected: 'talosta',
+			description: 'Grammar test for elative case'
+		},
+		{
+			word: 'pastöroitu',
+			grammarForm: 'partitive',
+			expected: 'pastöroitua',
+			description: 'Grammar test for partitive case'
+		},
+		{
+			word: 'talo',
+			grammarForm: 'partitive',
+			expected: 'taloa',
+			description: 'Grammar test for partitive case'
+		},
+		{
+			word: 'talo',
+			grammarForm: 'illative',
+			expected: 'taloon',
+			description: 'Grammar test for illative case'
+		},
+		{
+			word: 'linux',
+			grammarForm: 'inessive',
+			expected: 'linuxissa',
+			description: 'Grammar test for inessive case'
+		}
+	],
+
+	ru: [
+		{
+			word: 'тесть',
+			grammarForm: 'genitive',
+			expected: 'тестя',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'привилегия',
+			grammarForm: 'genitive',
+			expected: 'привилегии',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'установка',
+			grammarForm: 'genitive',
+			expected: 'установки',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'похоти',
+			grammarForm: 'genitive',
+			expected: 'похотей',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'доводы',
+			grammarForm: 'genitive',
+			expected: 'доводов',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'песчаник',
+			grammarForm: 'genitive',
+			expected: 'песчаника',
+			description: 'Grammar test for genitive case'
+		}
+	],
+
+
+	hu: [
+		{
+			word: 'Wikipédiá',
+			grammarForm: 'rol',
+			expected: 'Wikipédiáról',
+			description: 'Grammar test for rol case'
+		},
+		{
+			word: 'Wikipédiá',
+			grammarForm: 'ba',
+			expected: 'Wikipédiába',
+			description: 'Grammar test for ba case'
+		},
+		{
+			word: 'Wikipédiá',
+			grammarForm: 'k',
+			expected: 'Wikipédiák',
+			description: 'Grammar test for k case'
+		}
+	],
+
+	ga: [
+		{
+			word: 'an Domhnach',
+			grammarForm: 'ainmlae',
+			expected: 'Dé Domhnaigh',
+			description: 'Grammar test for ainmlae case'
+		},
+		{
+			word: 'an Luan',
+			grammarForm: 'ainmlae',
+			expected: 'Dé Luain',
+			description: 'Grammar test for ainmlae case'
+		},
+		{
+			word: 'an Satharn',
+			grammarForm: 'ainmlae',
+			expected: 'Dé Sathairn',
+			description: 'Grammar test for ainmlae case'
+		}
+	],
+
+	uk: [
+		{
+			word: 'тесть',
+			grammarForm: 'genitive',
+			expected: 'тестя',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'Вікіпедія',
+			grammarForm: 'genitive',
+			expected: 'Вікіпедії',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'установка',
+			grammarForm: 'genitive',
+			expected: 'установки',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'похоти',
+			grammarForm: 'genitive',
+			expected: 'похотей',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'доводы',
+			grammarForm: 'genitive',
+			expected: 'доводов',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'песчаник',
+			grammarForm: 'genitive',
+			expected: 'песчаника',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'Вікіпедія',
+			grammarForm: 'accusative',
+			expected: 'Вікіпедію',
+			description: 'Grammar test for accusative case'
+		}
+	],
+
+	sl: [
+		{
+			word: 'word',
+			grammarForm: 'orodnik',
+			expected: 'z word',
+			description: 'Grammar test for orodnik case'
+		},
+		{
+			word: 'word',
+			grammarForm: 'mestnik',
+			expected: 'o word',
+			description: 'Grammar test for mestnik case'
+		}
+	],
+
+	os: [
+		{
+			word: 'бæстæ',
+			grammarForm: 'genitive',
+			expected: 'бæсты',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'бæстæ',
+			grammarForm: 'allative',
+			expected: 'бæстæм',
+			description: 'Grammar test for allative case'
+		},
+		{
+			word: 'Тигр',
+			grammarForm: 'dative',
+			expected: 'Тигрæн',
+			description: 'Grammar test for dative case'
+		},
+		{
+			word: 'цъити',
+			grammarForm: 'dative',
+			expected: 'цъитийæн',
+			description: 'Grammar test for dative case'
+		},
+		{
+			word: 'лæппу',
+			grammarForm: 'genitive',
+			expected: 'лæппуйы',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: '2011',
+			grammarForm: 'equative',
+			expected: '2011-ау',
+			description: 'Grammar test for equative case'
+		}
+	],
+
+	la: [
+		{
+			word: 'Translatio',
+			grammarForm: 'genitive',
+			expected: 'Translationis',
+			description: 'Grammar test for genitive case'
+		},
+		{
+			word: 'Translatio',
+			grammarForm: 'accusative',
+			expected: 'Translationem',
+			description: 'Grammar test for accusative case'
+		},
+		{
+			word: 'Translatio',
+			grammarForm: 'ablative',
+			expected: 'Translatione',
+			description: 'Grammar test for ablative case'
+		}
+	]
+};
+
+$.each( grammarTests, function ( langCode, test ) {
+	if ( langCode === mw.config.get( 'wgUserLanguage' ) ) {
+		grammarTest( langCode, test );
+	}
+});
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.test.js
index e6934eda..be59f1ad 100644
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.test.js
@@ -1,71 +1,71 @@
-module( 'mediawiki', QUnit.newMwEnvironment() );
+( function ( mw ) {
 
-test( '-- Initial check', function() {
-	expect(8);
+QUnit.module( 'mediawiki', QUnit.newMwEnvironment() );
 
-	ok( window.jQuery, 'jQuery defined' );
-	ok( window.$, '$j defined' );
-	ok( window.$j, '$j defined' );
-	strictEqual( window.$, window.jQuery, '$ alias to jQuery' );
-	strictEqual( window.$j, window.jQuery, '$j alias to jQuery' );
+QUnit.test( 'Initial check', 8, function ( assert ) {
+	assert.ok( window.jQuery, 'jQuery defined' );
+	assert.ok( window.$, '$j defined' );
+	assert.ok( window.$j, '$j defined' );
+	assert.strictEqual( window.$, window.jQuery, '$ alias to jQuery' );
+	assert.strictEqual( window.$j, window.jQuery, '$j alias to jQuery' );
 
-	ok( window.mediaWiki, 'mediaWiki defined' );
-	ok( window.mw, 'mw defined' );
-	strictEqual( window.mw, window.mediaWiki, 'mw alias to mediaWiki' );
+	assert.ok( window.mediaWiki, 'mediaWiki defined' );
+	assert.ok( window.mw, 'mw defined' );
+	assert.strictEqual( window.mw, window.mediaWiki, 'mw alias to mediaWiki' );
 });
 
-test( 'mw.Map', function() {
-	expect(17);
+QUnit.test( 'mw.Map', 17, function ( assert ) {
+	var arry, conf, funky, globalConf, nummy, someValues;
 
-	ok( mw.Map, 'mw.Map defined' );
+	assert.ok( mw.Map, 'mw.Map defined' );
 
-	var	conf = new mw.Map(),
-		// Dummy variables
-		funky = function() {},
-		arry = [],
-		nummy = 7;
+	conf = new mw.Map();
+	// Dummy variables
+	funky = function () {};
+	arry = [];
+	nummy = 7;
 
 	// Tests for input validation
-	strictEqual( conf.get( 'inexistantKey' ), null, 'Map.get returns null if selection was a string and the key was not found' );
-	strictEqual( conf.set( 'myKey', 'myValue' ), true, 'Map.set returns boolean true if a value was set for a valid key string' );
-	strictEqual( conf.set( funky, 'Funky' ), false, 'Map.set returns boolean false if key was invalid (Function)' );
-	strictEqual( conf.set( arry, 'Arry' ), false, 'Map.set returns boolean false if key was invalid (Array)' );
-	strictEqual( conf.set( nummy, 'Nummy' ), false, 'Map.set returns boolean false if key was invalid (Number)' );
-	equal( conf.get( 'myKey' ), 'myValue', 'Map.get returns a single value value correctly' );
-	strictEqual( conf.get( nummy ), null, 'Map.get ruturns null if selection was invalid (Number)' );
-	strictEqual( conf.get( funky ), null, 'Map.get ruturns null if selection was invalid (Function)' );
+	assert.strictEqual( conf.get( 'inexistantKey' ), null, 'Map.get returns null if selection was a string and the key was not found' );
+	assert.strictEqual( conf.set( 'myKey', 'myValue' ), true, 'Map.set returns boolean true if a value was set for a valid key string' );
+	assert.strictEqual( conf.set( funky, 'Funky' ), false, 'Map.set returns boolean false if key was invalid (Function)' );
+	assert.strictEqual( conf.set( arry, 'Arry' ), false, 'Map.set returns boolean false if key was invalid (Array)' );
+	assert.strictEqual( conf.set( nummy, 'Nummy' ), false, 'Map.set returns boolean false if key was invalid (Number)' );
+	assert.equal( conf.get( 'myKey' ), 'myValue', 'Map.get returns a single value value correctly' );
+	assert.strictEqual( conf.get( nummy ), null, 'Map.get ruturns null if selection was invalid (Number)' );
+	assert.strictEqual( conf.get( funky ), null, 'Map.get ruturns null if selection was invalid (Function)' );
 
 	// Multiple values at once
-	var someValues = {
+	someValues = {
 		'foo': 'bar',
 		'lorem': 'ipsum',
 		'MediaWiki': true
 	};
-	strictEqual( conf.set( someValues ), true, 'Map.set returns boolean true if multiple values were set by passing an object' );
-	deepEqual( conf.get( ['foo', 'lorem'] ), {
+	assert.strictEqual( conf.set( someValues ), true, 'Map.set returns boolean true if multiple values were set by passing an object' );
+	assert.deepEqual( conf.get( ['foo', 'lorem'] ), {
 		'foo': 'bar',
 		'lorem': 'ipsum'
 	}, 'Map.get returns multiple values correctly as an object' );
 
-	deepEqual( conf.get( ['foo', 'notExist'] ), {
+	assert.deepEqual( conf.get( ['foo', 'notExist'] ), {
 		'foo': 'bar',
 		'notExist': null
 	}, 'Map.get return includes keys that were not found as null values' );
 
-	strictEqual( conf.exists( 'foo' ), true, 'Map.exists returns boolean true if a key exists' );
-	strictEqual( conf.exists( 'notExist' ), false, 'Map.exists returns boolean false if a key does not exists' );
+	assert.strictEqual( conf.exists( 'foo' ), true, 'Map.exists returns boolean true if a key exists' );
+	assert.strictEqual( conf.exists( 'notExist' ), false, 'Map.exists returns boolean false if a key does not exists' );
 
 	// Interacting with globals and accessing the values object
-	strictEqual( conf.get(), conf.values, 'Map.get returns the entire values object by reference (if called without arguments)' );
+	assert.strictEqual( conf.get(), conf.values, 'Map.get returns the entire values object by reference (if called without arguments)' );
 
 	conf.set( 'globalMapChecker', 'Hi' );
 
-	ok( false === 'globalMapChecker' in window, 'new mw.Map did not store its values in the global window object by default' );
+	assert.ok( false === 'globalMapChecker' in window, 'new mw.Map did not store its values in the global window object by default' );
 
-	var globalConf = new mw.Map( true );
+	globalConf = new mw.Map( true );
 	globalConf.set( 'anotherGlobalMapChecker', 'Hello' );
 
-	ok( 'anotherGlobalMapChecker' in window, 'new mw.Map( true ) did store its values in the global window object' );
+	assert.ok( 'anotherGlobalMapChecker' in window, 'new mw.Map( true ) did store its values in the global window object' );
 
 	// Whitelist this global variable for QUnit's 'noglobal' mode
 	if ( QUnit.config.noglobals ) {
@@ -73,124 +73,488 @@ test( 'mw.Map', function() {
 	}
 });
 
-test( 'mw.config', function() {
-	expect(1);
-
-	ok( mw.config instanceof mw.Map, 'mw.config instance of mw.Map' );
+QUnit.test( 'mw.config', 1, function ( assert ) {
+	assert.ok( mw.config instanceof mw.Map, 'mw.config instance of mw.Map' );
 });
 
-test( 'mw.message & mw.messages', function() {
-	expect(20);
+QUnit.test( 'mw.message & mw.messages', 20, function ( assert ) {
+	var goodbye, hello, pluralMessage;
 
-	ok( mw.messages, 'messages defined' );
-	ok( mw.messages instanceof mw.Map, 'mw.messages instance of mw.Map' );
-	ok( mw.messages.set( 'hello', 'Hello <b>awesome</b> world' ), 'mw.messages.set: Register' );
+	assert.ok( mw.messages, 'messages defined' );
+	assert.ok( mw.messages instanceof mw.Map, 'mw.messages instance of mw.Map' );
+	assert.ok( mw.messages.set( 'hello', 'Hello <b>awesome</b> world' ), 'mw.messages.set: Register' );
 
-	var hello = mw.message( 'hello' );
+	hello = mw.message( 'hello' );
 
-	equal( hello.format, 'plain', 'Message property "format" defaults to "plain"' );
-	strictEqual( hello.map, mw.messages, 'Message property "map" defaults to the global instance in mw.messages' );
-	equal( hello.key, 'hello', 'Message property "key" (currect key)' );
-	deepEqual( hello.parameters, [], 'Message property "parameters" defaults to an empty array' );
+	assert.equal( hello.format, 'plain', 'Message property "format" defaults to "plain"' );
+	assert.strictEqual( hello.map, mw.messages, 'Message property "map" defaults to the global instance in mw.messages' );
+	assert.equal( hello.key, 'hello', 'Message property "key" (currect key)' );
+	assert.deepEqual( hello.parameters, [], 'Message property "parameters" defaults to an empty array' );
 
 	// Todo
-	ok( hello.params, 'Message prototype "params"' );
+	assert.ok( hello.params, 'Message prototype "params"' );
 
 	hello.format = 'plain';
-	equal( hello.toString(), 'Hello <b>awesome</b> world', 'Message.toString returns the message as a string with the current "format"' );
+	assert.equal( hello.toString(), 'Hello <b>awesome</b> world', 'Message.toString returns the message as a string with the current "format"' );
 
-	equal( hello.escaped(), 'Hello &lt;b&gt;awesome&lt;/b&gt; world', 'Message.escaped returns the escaped message' );
-	equal( hello.format, 'escaped', 'Message.escaped correctly updated the "format" property' );
+	assert.equal( hello.escaped(), 'Hello &lt;b&gt;awesome&lt;/b&gt; world', 'Message.escaped returns the escaped message' );
+	assert.equal( hello.format, 'escaped', 'Message.escaped correctly updated the "format" property' );
 
 	hello.parse();
-	equal( hello.format, 'parse', 'Message.parse correctly updated the "format" property' );
+	assert.equal( hello.format, 'parse', 'Message.parse correctly updated the "format" property' );
 
 	hello.plain();
-	equal( hello.format, 'plain', 'Message.plain correctly updated the "format" property' );
+	assert.equal( hello.format, 'plain', 'Message.plain correctly updated the "format" property' );
 
-	strictEqual( hello.exists(), true, 'Message.exists returns true for existing messages' );
+	assert.strictEqual( hello.exists(), true, 'Message.exists returns true for existing messages' );
 
-	var goodbye = mw.message( 'goodbye' );
-	strictEqual( goodbye.exists(), false, 'Message.exists returns false for nonexistent messages' );
+	goodbye = mw.message( 'goodbye' );
+	assert.strictEqual( goodbye.exists(), false, 'Message.exists returns false for nonexistent messages' );
 
-	equal( goodbye.plain(), '<goodbye>', 'Message.toString returns plain <key> if format is "plain" and key does not exist' );
+	assert.equal( goodbye.plain(), '<goodbye>', 'Message.toString returns plain <key> if format is "plain" and key does not exist' );
 	// bug 30684
-	equal( goodbye.escaped(), '&lt;goodbye&gt;', 'Message.toString returns properly escaped &lt;key&gt; if format is "escaped" and key does not exist' );
+	assert.equal( goodbye.escaped(), '&lt;goodbye&gt;', 'Message.toString returns properly escaped &lt;key&gt; if format is "escaped" and key does not exist' );
 
-	ok( mw.messages.set( 'pluraltestmsg', 'There {{PLURAL:$1|is|are}} $1 {{PLURAL:$1|result|results}}' ), 'mw.messages.set: Register' );
-	var pluralMessage = mw.message( 'pluraltestmsg' , 6 );
-	equal( pluralMessage.plain(), 'There are 6 results', 'plural get resolved when format is plain' );
-	equal( pluralMessage.parse(), 'There are 6 results', 'plural get resolved when format is parse' );
+	assert.ok( mw.messages.set( 'pluraltestmsg', 'There {{PLURAL:$1|is|are}} $1 {{PLURAL:$1|result|results}}' ), 'mw.messages.set: Register' );
+	pluralMessage = mw.message( 'pluraltestmsg' , 6 );
+	assert.equal( pluralMessage.plain(), 'There are 6 results', 'plural get resolved when format is plain' );
+	assert.equal( pluralMessage.parse(), 'There are 6 results', 'plural get resolved when format is parse' );
 
 });
 
-test( 'mw.msg', function() {
-	expect(11);
-
-	ok( mw.messages.set( 'hello', 'Hello <b>awesome</b> world' ), 'mw.messages.set: Register' );
-	equal( mw.msg( 'hello' ), 'Hello <b>awesome</b> world', 'Gets message with default options (existing message)' );
-	equal( mw.msg( 'goodbye' ), '<goodbye>', 'Gets message with default options (nonexistent message)' );
+QUnit.test( 'mw.msg', 11, function ( assert ) {
+	assert.ok( mw.messages.set( 'hello', 'Hello <b>awesome</b> world' ), 'mw.messages.set: Register' );
+	assert.equal( mw.msg( 'hello' ), 'Hello <b>awesome</b> world', 'Gets message with default options (existing message)' );
+	assert.equal( mw.msg( 'goodbye' ), '<goodbye>', 'Gets message with default options (nonexistent message)' );
 
-	ok( mw.messages.set( 'plural-item' , 'Found $1 {{PLURAL:$1|item|items}}' ) );
-	equal( mw.msg( 'plural-item', 5 ), 'Found 5 items', 'Apply plural for count 5' );
-	equal( mw.msg( 'plural-item', 0 ), 'Found 0 items', 'Apply plural for count 0' );
-	equal( mw.msg( 'plural-item', 1 ), 'Found 1 item', 'Apply plural for count 1' );
+	assert.ok( mw.messages.set( 'plural-item' , 'Found $1 {{PLURAL:$1|item|items}}' ) );
+	assert.equal( mw.msg( 'plural-item', 5 ), 'Found 5 items', 'Apply plural for count 5' );
+	assert.equal( mw.msg( 'plural-item', 0 ), 'Found 0 items', 'Apply plural for count 0' );
+	assert.equal( mw.msg( 'plural-item', 1 ), 'Found 1 item', 'Apply plural for count 1' );
 
-	ok( mw.messages.set('gender-plural-msg' , '{{GENDER:$1|he|she|they}} {{PLURAL:$2|is|are}} awesome' ) );
-	equal( mw.msg( 'gender-plural-msg', 'male', 1 ), 'he is awesome', 'Gender test for male, plural count 1' );
-	equal( mw.msg( 'gender-plural-msg', 'female', '1' ), 'she is awesome', 'Gender test for female, plural count 1' );
-	equal( mw.msg( 'gender-plural-msg', 'unknown', 10 ), 'they are awesome', 'Gender test for neutral, plural count 10' );
+	assert.ok( mw.messages.set('gender-plural-msg' , '{{GENDER:$1|he|she|they}} {{PLURAL:$2|is|are}} awesome' ) );
+	assert.equal( mw.msg( 'gender-plural-msg', 'male', 1 ), 'he is awesome', 'Gender test for male, plural count 1' );
+	assert.equal( mw.msg( 'gender-plural-msg', 'female', '1' ), 'she is awesome', 'Gender test for female, plural count 1' );
+	assert.equal( mw.msg( 'gender-plural-msg', 'unknown', 10 ), 'they are awesome', 'Gender test for neutral, plural count 10' );
 
 });
 
-test( 'mw.loader', function() {
-	expect(1);
+/**
+ * The sync style load test (for @import). This is, in a way, also an open bug for
+ * ResourceLoader ("execute js after styles are loaded"), but browsers don't offer a
+ * way to get a callback from when a stylesheet is loaded (that is, including any
+ * @import rules inside). To work around this, we'll have a little time loop to check
+ * if the styles apply.
+ * Note: This test originally used new Image() and onerror to get a callback
+ * when the url is loaded, but that is fragile since it doesn't monitor the
+ * same request as the css @import, and Safari 4 has issues with
+ * onerror/onload not being fired at all in weird cases like this.
+ */
+function assertStyleAsync( assert, $element, prop, val, fn ) {
+	var styleTestStart,
+		el = $element.get( 0 ),
+		styleTestTimeout = ( QUnit.config.testTimeout - 200 ) || 5000;
+
+	function isCssImportApplied() {
+		// Trigger reflow, repaint, redraw, whatever (cross-browser)
+		var x = $element.css( 'height' );
+		x = el.innerHTML;
+		el.className = el.className;
+		x = document.documentElement.clientHeight;
+
+		return $element.css( prop ) === val;
+	}
+
+	function styleTestLoop() {
+		var styleTestSince = new Date().getTime() - styleTestStart;
+		// If it is passing or if we timed out, run the real test and stop the loop
+		if ( isCssImportApplied() || styleTestSince > styleTestTimeout ) {
+			assert.equal( $element.css( prop ), val,
+				'style "' + prop + ': ' + val + '" from url is applied (after ' + styleTestSince + 'ms)'
+			);
+
+			if ( fn ) {
+				fn();
+			}
+
+			return;
+		}
+		// Otherwise, keep polling
+		setTimeout( styleTestLoop, 150 );
+	}
+
+	// Start the loop
+	styleTestStart = new Date().getTime();
+	styleTestLoop();
+}
+
+function urlStyleTest( selector, prop, val ) {
+	return QUnit.fixurl(
+		mw.config.get( 'wgScriptPath' ) +
+			'/tests/qunit/data/styleTest.css.php?' +
+			$.param( {
+				selector: selector,
+				prop: prop,
+				val: val
+			} )
+	);
+}
+
+QUnit.asyncTest( 'mw.loader', 2, function ( assert ) {
+	var isAwesomeDone;
 
-	// Asynchronous ahead
-	stop();
+	mw.loader.testCallback = function () {
+		QUnit.start();
+		assert.strictEqual( isAwesomeDone, undefined, 'Implementing module is.awesome: isAwesomeDone should still be undefined');
+		isAwesomeDone = true;
+	};
 
-	mw.loader.implement( 'is.awesome', [QUnit.fixurl( mw.config.get( 'wgScriptPath' ) + '/tests/qunit/data/defineTestCallback.js' )], {}, {} );
+	mw.loader.implement( 'test.callback', [QUnit.fixurl( mw.config.get( 'wgScriptPath' ) + '/tests/qunit/data/callMwLoaderTestCallback.js' )], {}, {} );
 
-	mw.loader.using( 'is.awesome', function() {
+	mw.loader.using( 'test.callback', function () {
 
 		// /sample/awesome.js declares the "mw.loader.testCallback" function
 		// which contains a call to start() and ok()
-		mw.loader.testCallback();
-		mw.loader.testCallback = undefined;
+		assert.strictEqual( isAwesomeDone, true, "test.callback module should've caused isAwesomeDone to be true" );
+		delete mw.loader.testCallback;
 
-	}, function() {
-		start();
-		ok( false, 'Error callback fired while implementing "is.awesome" module' );
+	}, function () {
+		QUnit.start();
+		assert.ok( false, 'Error callback fired while loader.using "test.callback" module' );
 	});
-
 });
 
-test( 'mw.loader.bug29107' , function() {
-	expect(2);
+QUnit.test( 'mw.loader.implement( styles={ "css": [text, ..] } )', 2, function ( assert ) {
+	var $element = $( '<div class="mw-test-implement-a"></div>' ).appendTo( '#qunit-fixture' );
+
+	assert.notEqual(
+		$element.css( 'float' ),
+		'right',
+		'style is clear'
+	);
+
+	mw.loader.implement(
+		'test.implement.a',
+		function () {
+			assert.equal(
+				$element.css( 'float' ),
+				'right',
+				'style is applied'
+			);
+		},
+		{
+			'all': '.mw-test-implement-a { float: right; }'
+		},
+		{}
+	);
+
+	mw.loader.load([
+		'test.implement.a'
+	]);
+} );
+
+QUnit.asyncTest( 'mw.loader.implement( styles={ "url": { <media>: [url, ..] } } )', 7, function ( assert ) {
+	var $element1 = $( '<div class="mw-test-implement-b1"></div>' ).appendTo( '#qunit-fixture' ),
+		$element2 = $( '<div class="mw-test-implement-b2"></div>' ).appendTo( '#qunit-fixture' ),
+		$element3 = $( '<div class="mw-test-implement-b3"></div>' ).appendTo( '#qunit-fixture' );
+
+	assert.notEqual(
+		$element1.css( 'text-align' ),
+		'center',
+		'style is clear'
+	);
+	assert.notEqual(
+		$element2.css( 'float' ),
+		'left',
+		'style is clear'
+	);
+	assert.notEqual(
+		$element3.css( 'text-align' ),
+		'right',
+		'style is clear'
+	);
+
+	mw.loader.implement(
+		'test.implement.b',
+		function () {
+			assertStyleAsync( assert, $element2, 'float', 'left', function () {
+				assert.notEqual( $element1.css( 'text-align' ), 'center', 'print style is not applied' );
+
+				QUnit.start();
+			} );
+			assertStyleAsync( assert, $element3, 'float', 'right', function () {
+				assert.notEqual( $element1.css( 'text-align' ), 'center', 'print style is not applied' );
+
+				QUnit.start();
+			} );
+		},
+		{
+			'url': {
+				'print': [urlStyleTest( '.mw-test-implement-b1', 'text-align', 'center' )],
+				'screen': [
+					// bug 40834: Make sure it actually works with more than 1 stylesheet reference
+					urlStyleTest( '.mw-test-implement-b2', 'float', 'left' ),
+					urlStyleTest( '.mw-test-implement-b3', 'float', 'right' )
+				]
+			}
+		},
+		{}
+	);
+
+	mw.loader.load([
+		'test.implement.b'
+	]);
+} );
+
+// Backwards compatibility
+QUnit.test( 'mw.loader.implement( styles={ <media>: text } ) (back-compat)', 2, function ( assert ) {
+	var $element = $( '<div class="mw-test-implement-c"></div>' ).appendTo( '#qunit-fixture' );
+
+	assert.notEqual(
+		$element.css( 'float' ),
+		'right',
+		'style is clear'
+	);
+
+	mw.loader.implement(
+		'test.implement.c',
+		function () {
+			assert.equal(
+				$element.css( 'float' ),
+				'right',
+				'style is applied'
+			);
+		},
+		{
+			'all': '.mw-test-implement-c { float: right; }'
+		},
+		{}
+	);
+
+	mw.loader.load([
+		'test.implement.c'
+	]);
+} );
+
+// Backwards compatibility
+QUnit.asyncTest( 'mw.loader.implement( styles={ <media>: [url, ..] } ) (back-compat)', 4, function ( assert ) {
+	var $element = $( '<div class="mw-test-implement-d"></div>' ).appendTo( '#qunit-fixture' ),
+		$element2 = $( '<div class="mw-test-implement-d2"></div>' ).appendTo( '#qunit-fixture' );
+
+	assert.notEqual(
+		$element.css( 'float' ),
+		'right',
+		'style is clear'
+	);
+	assert.notEqual(
+		$element2.css( 'text-align' ),
+		'center',
+		'style is clear'
+	);
+
+	mw.loader.implement(
+		'test.implement.d',
+		function () {
+			assertStyleAsync( assert, $element, 'float', 'right', function () {
+
+				assert.notEqual( $element2.css( 'text-align' ), 'center', 'print style is not applied (bug 40500)' );
+
+				QUnit.start();
+			} );
+		},
+		{
+			'all': [urlStyleTest( '.mw-test-implement-d', 'float', 'right' )],
+			'print': [urlStyleTest( '.mw-test-implement-d2', 'text-align', 'center' )]
+		},
+		{}
+	);
 
-	// Message doesn't exist already
-	ok( !mw.messages.exists( 'bug29107' ) );
+	mw.loader.load([
+		'test.implement.d'
+	]);
+} );
+
+// @import (bug 31676)
+QUnit.asyncTest( 'mw.loader.implement( styles has @import)', 5, function ( assert ) {
+	var isJsExecuted, $element;
+
+	mw.loader.implement(
+		'test.implement.import',
+		function () {
+			assert.strictEqual( isJsExecuted, undefined, 'javascript not executed multiple times' );
+			isJsExecuted = true;
+
+			assert.equal( mw.loader.getState( 'test.implement.import' ), 'ready', 'module state is "ready" while implement() is executing javascript' );
+
+			$element = $( '<div class="mw-test-implement-import">Foo bar</div>' ).appendTo( '#qunit-fixture' );
+
+			assert.equal( mw.msg( 'test-foobar' ), 'Hello Foobar, $1!', 'Messages are loaded before javascript execution' );
+
+			assertStyleAsync( assert, $element, 'float', 'right', function () {
+				assert.equal( $element.css( 'text-align' ),'center',
+					'CSS styles after the @import rule are working'
+				);
+
+				QUnit.start();
+			} );
+		},
+		{
+			'css': [
+				'@import url(\''
+				+ urlStyleTest( '.mw-test-implement-import', 'float', 'right' )
+				+ '\');\n'
+				+ '.mw-test-implement-import { text-align: center; }'
+			]
+		},
+		{
+			'test-foobar': 'Hello Foobar, $1!'
+		}
+	);
+
+	mw.loader.load( 'test.implement' );
+
+});
 
-	// Async! Failure in this test may lead to neither the success nor error callbacks getting called.
-	// Due to QUnit's timeout feauture we won't hang here forever if this happends.
-	stop();
+QUnit.asyncTest( 'mw.loader.implement( only messages )' , 2, function ( assert ) {
+	assert.assertFalse( mw.messages.exists( 'bug_29107' ), 'Verify that the test message doesn\'t exist yet' );
 
-	mw.loader.implement( 'bug29107.messages-only', [], {}, {'bug29107': 'loaded'} );
-	mw.loader.using( 'bug29107.messages-only', function() {
-		start();
-		ok( mw.messages.exists( 'bug29107' ), 'Bug 29107: messages-only module should implement ok' );
+	mw.loader.implement( 'test.implement.msgs', [], {}, { 'bug_29107': 'loaded' } );
+	mw.loader.using( 'test.implement.msgs', function() {
+		QUnit.start();
+		assert.ok( mw.messages.exists( 'bug_29107' ), 'Bug 29107: messages-only module should implement ok' );
 	}, function() {
-		start();
-		ok( false, 'Error callback fired while implementing "bug29107.messages-only" module' );
+		QUnit.start();
+		assert.ok( false, 'Error callback fired while implementing "test.implement.msgs" module' );
 	});
 });
 
-test( 'mw.loader.bug30825', function() {
+QUnit.test( 'mw.loader erroneous indirect dependency', 3, function ( assert ) {
+	mw.loader.register( [
+		['test.module1', '0'],
+		['test.module2', '0', ['test.module1']],
+		['test.module3', '0', ['test.module2']]
+	] );
+	mw.loader.implement( 'test.module1', function () { throw new Error( 'expected' ); }, {}, {} );
+	assert.strictEqual( mw.loader.getState( 'test.module1' ), 'error', 'Expected "error" state for test.module1' );
+	assert.strictEqual( mw.loader.getState( 'test.module2' ), 'error', 'Expected "error" state for test.module2' );
+	assert.strictEqual( mw.loader.getState( 'test.module3' ), 'error', 'Expected "error" state for test.module3' );
+} );
+
+QUnit.test( 'mw.loader out-of-order implementation', 9, function ( assert ) {
+	mw.loader.register( [
+		['test.module4', '0'],
+		['test.module5', '0', ['test.module4']],
+		['test.module6', '0', ['test.module5']]
+	] );
+	mw.loader.implement( 'test.module4', function () {}, {}, {} );
+	assert.strictEqual( mw.loader.getState( 'test.module4' ), 'ready', 'Expected "ready" state for test.module4' );
+	assert.strictEqual( mw.loader.getState( 'test.module5' ), 'registered', 'Expected "registered" state for test.module5' );
+	assert.strictEqual( mw.loader.getState( 'test.module6' ), 'registered', 'Expected "registered" state for test.module6' );
+	mw.loader.implement( 'test.module6', function () {}, {}, {} );
+	assert.strictEqual( mw.loader.getState( 'test.module4' ), 'ready', 'Expected "ready" state for test.module4' );
+	assert.strictEqual( mw.loader.getState( 'test.module5' ), 'registered', 'Expected "registered" state for test.module5' );
+	assert.strictEqual( mw.loader.getState( 'test.module6' ), 'loaded', 'Expected "loaded" state for test.module6' );
+	mw.loader.implement( 'test.module5', function() {}, {}, {} );
+	assert.strictEqual( mw.loader.getState( 'test.module4' ), 'ready', 'Expected "ready" state for test.module4' );
+	assert.strictEqual( mw.loader.getState( 'test.module5' ), 'ready', 'Expected "ready" state for test.module5' );
+	assert.strictEqual( mw.loader.getState( 'test.module6' ), 'ready', 'Expected "ready" state for test.module6' );
+} );
+
+QUnit.test( 'mw.loader missing dependency', 13, function ( assert ) {
+	mw.loader.register( [
+		['test.module7', '0'],
+		['test.module8', '0', ['test.module7']],
+		['test.module9', '0', ['test.module8']]
+	] );
+	mw.loader.implement( 'test.module8', function () {}, {}, {} );
+	assert.strictEqual( mw.loader.getState( 'test.module7' ), 'registered', 'Expected "registered" state for test.module7' );
+	assert.strictEqual( mw.loader.getState( 'test.module8' ), 'loaded', 'Expected "loaded" state for test.module8' );
+	assert.strictEqual( mw.loader.getState( 'test.module9' ), 'registered', 'Expected "registered" state for test.module9' );
+	mw.loader.state( 'test.module7', 'missing' );
+	assert.strictEqual( mw.loader.getState( 'test.module7' ), 'missing', 'Expected "missing" state for test.module7' );
+	assert.strictEqual( mw.loader.getState( 'test.module8' ), 'error', 'Expected "error" state for test.module8' );
+	assert.strictEqual( mw.loader.getState( 'test.module9' ), 'error', 'Expected "error" state for test.module9' );
+	mw.loader.implement( 'test.module9', function () {}, {}, {} );
+	assert.strictEqual( mw.loader.getState( 'test.module7' ), 'missing', 'Expected "missing" state for test.module7' );
+	assert.strictEqual( mw.loader.getState( 'test.module8' ), 'error', 'Expected "error" state for test.module8' );
+	assert.strictEqual( mw.loader.getState( 'test.module9' ), 'error', 'Expected "error" state for test.module9' );
+	mw.loader.using(
+		['test.module7'],
+		function () {
+			assert.ok( false, "Success fired despite missing dependency" );
+			assert.ok( true , "QUnit expected() count dummy" );
+		},
+		function ( e, dependencies ) {
+			assert.strictEqual( $.isArray( dependencies ), true, 'Expected array of dependencies' );
+			assert.deepEqual( dependencies, ['test.module7'], 'Error callback called with module test.module7' );
+		}
+	);
+	mw.loader.using(
+		['test.module9'],
+		function () {
+			assert.ok( false, "Success fired despite missing dependency" );
+			assert.ok( true , "QUnit expected() count dummy" );
+		},
+		function ( e, dependencies ) {
+			assert.strictEqual( $.isArray( dependencies ), true, 'Expected array of dependencies' );
+			dependencies.sort();
+			assert.deepEqual(
+				dependencies,
+				['test.module7', 'test.module8', 'test.module9'],
+				'Error callback called with all three modules as dependencies'
+			);
+		}
+	);
+} );
+
+QUnit.asyncTest( 'mw.loader dependency handling', 5, function ( assert ) {
+	mw.loader.addSource(
+		'testloader',
+		{
+			loadScript: QUnit.fixurl( mw.config.get( 'wgScriptPath' ) + '/tests/qunit/data/load.mock.php' )
+		}
+	);
+
+	mw.loader.register( [
+		// [module, version, dependencies, group, source]
+		['testMissing', '1', [], null, 'testloader'],
+		['testUsesMissing', '1', ['testMissing'], null, 'testloader'],
+		['testUsesNestedMissing', '1', ['testUsesMissing'], null, 'testloader']
+	] );
+
+	function verifyModuleStates() {
+		assert.equal( mw.loader.getState( 'testMissing' ), 'missing', 'Module not known to server must have state "missing"' );
+		assert.equal( mw.loader.getState( 'testUsesMissing' ), 'error', 'Module with missing dependency must have state "error"' );
+		assert.equal( mw.loader.getState( 'testUsesNestedMissing' ), 'error', 'Module with indirect missing dependency must have state "error"' );
+	}
+
+	mw.loader.using( ['testUsesNestedMissing'],
+		function () {
+			assert.ok( false, 'Error handler should be invoked.' );
+			assert.ok( true ); // Dummy to reach QUnit expect()
+
+			verifyModuleStates();
+
+			QUnit.start();
+		},
+		function ( e, badmodules ) {
+			assert.ok( true, 'Error handler should be invoked.' );
+			// As soon as server spits out state('testMissing', 'missing');
+			// it will bubble up and trigger the error callback.
+			// Therefor the badmodules array is not testUsesMissing or testUsesNestedMissing.
+			assert.deepEqual( badmodules, ['testMissing'], 'Bad modules as expected.' );
+
+			verifyModuleStates();
+
+			QUnit.start();
+		}
+	);
+} );
+
+QUnit.asyncTest( 'mw.loader( "//protocol-relative" ) (bug 30825)', 2, function ( assert ) {
 	// This bug was actually already fixed in 1.18 and later when discovered in 1.17.
 	// Test is for regressions!
 
-	expect(2);
-
 	// Forge an URL to the test callback script
 	var target = QUnit.fixurl(
 		mw.config.get( 'wgServer' ) + mw.config.get( 'wgScriptPath' ) + '/tests/qunit/data/qunitOkCall.js'
@@ -199,31 +563,31 @@ test( 'mw.loader.bug30825', function() {
 	// Confirm that mw.loader.load() works with protocol-relative URLs
 	target = target.replace( /https?:/, '' );
 
-	equal( target.substr( 0, 2 ), '//',
+	assert.equal( target.substr( 0, 2 ), '//',
 		'URL must be relative to test relative URLs!'
 	);
 
 	// Async!
-	stop();
+	// The target calls QUnit.start
 	mw.loader.load( target );
 });
 
-test( 'mw.html', function() {
-	expect(11);
-
-	raises( function(){
+QUnit.test( 'mw.html', 13, function ( assert ) {
+	assert.throws( function () {
 		mw.html.escape();
 	}, TypeError, 'html.escape throws a TypeError if argument given is not a string' );
 
-	equal( mw.html.escape( '<mw awesome="awesome" value=\'test\' />' ),
-		'&lt;mw awesome=&quot;awesome&quot; value=&#039;test&#039; /&gt;', 'html.escape escapes html snippet' );
+	assert.equal( mw.html.escape( '<mw awesome="awesome" value=\'test\' />' ),
+		'&lt;mw awesome=&quot;awesome&quot; value=&#039;test&#039; /&gt;', 'escape() escapes special characters to html entities' );
 
-	equal( mw.html.element(),
-		'<undefined/>', 'html.element Always return a valid html string (even without arguments)' );
+	assert.equal( mw.html.element(),
+		'<undefined/>', 'element() always returns a valid html string (even without arguments)' );
 
-	equal( mw.html.element( 'div' ), '<div/>', 'html.element DIV (simple)' );
+	assert.equal( mw.html.element( 'div' ), '<div/>', 'element() Plain DIV (simple)' );
 
-	equal(
+	assert.equal( mw.html.element( 'div', {}, '' ), '<div></div>', 'element() Basic DIV (simple)' );
+
+	assert.equal(
 		mw.html.element(
 			'div', {
 				id: 'foobar'
@@ -232,11 +596,24 @@ test( 'mw.html', function() {
 		'<div id="foobar"/>',
 		'html.element DIV (attribs)' );
 
-	equal( mw.html.element( 'p', null, 12 ), '<p>12</p>', 'Numbers are valid content and should be casted to a string' );
+	assert.equal( mw.html.element( 'p', null, 12 ), '<p>12</p>', 'Numbers are valid content and should be casted to a string' );
+
+	assert.equal( mw.html.element( 'p', { title: 12 }, '' ), '<p title="12"></p>', 'Numbers are valid attribute values' );
 
-	equal( mw.html.element( 'p', { title: 12 }, '' ), '<p title="12"></p>', 'Numbers are valid attribute values' );
+	// Example from https://www.mediawiki.org/wiki/ResourceLoader/Default_modules#mediaWiki.html
+	assert.equal(
+		mw.html.element(
+			'div',
+			{},
+			new mw.html.Raw(
+				mw.html.element( 'img', { src: '<' } )
+			)
+		),
+		'<div><img src="&lt;"/></div>',
+		'Raw inclusion of another element'
+	);
 
-	equal(
+	assert.equal(
 		mw.html.element(
 			'option', {
 				selected: true
@@ -246,7 +623,7 @@ test( 'mw.html', function() {
 		'Attributes may have boolean values. True copies the attribute name to the value.'
 	);
 
-	equal(
+	assert.equal(
 		mw.html.element(
 			'option', {
 				value: 'foo',
@@ -257,14 +634,16 @@ test( 'mw.html', function() {
 		'Attributes may have boolean values. False keeps the attribute from output.'
 	);
 
-	equal( mw.html.element( 'div',
+	assert.equal( mw.html.element( 'div',
 			null, 'a' ),
 		'<div>a</div>',
 		'html.element DIV (content)' );
 
-	equal( mw.html.element( 'a',
+	assert.equal( mw.html.element( 'a',
 			{ href: 'http://mediawiki.org/w/index.php?title=RL&action=history' }, 'a' ),
 		'<a href="http://mediawiki.org/w/index.php?title=RL&amp;action=history">a</a>',
 		'html.element DIV (attribs + content)' );
 
 });
+
+}( mediaWiki ) );
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.user.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.user.test.js
index 15265db5..16c97dff 100644
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.user.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.user.test.js
@@ -1,21 +1,12 @@
-module( 'mediawiki.user', QUnit.newMwEnvironment() );
+( function ( mw ) {
 
-test( '-- Initial check', function() {
-	expect(1);
+QUnit.module( 'mediawiki.user', QUnit.newMwEnvironment() );
 
-	ok( mw.user, 'mw.user defined' );
+QUnit.test( 'options', 1, function ( assert ) {
+	assert.ok( mw.user.options instanceof mw.Map, 'options instance of mw.Map' );
 });
 
-
-test( 'options', function() {
-	expect(1);
-
-	ok( mw.user.options instanceof mw.Map, 'options instance of mw.Map' );
-});
-
-test( 'User login status', function() {
-	expect(5);
-
+QUnit.test( 'user status', 9, function ( assert ) {
 	/**
 	 * Tests can be run under three different conditions:
 	 *   1) From tests/qunit/index.html, user will be anonymous.
@@ -24,16 +15,42 @@ test( 'User login status', function() {
 	 */
 
 	// Forge an anonymous user:
-	mw.config.set( 'wgUserName', null);
+	mw.config.set( 'wgUserName', null );
 
-	strictEqual( mw.user.name(), null, 'user.name should return null when anonymous' );
-	ok( mw.user.anonymous(), 'user.anonymous should reutrn true when anonymous' );
+	assert.strictEqual( mw.user.getName(), null, 'user.getName() returns null when anonymous' );
+	assert.strictEqual( mw.user.name(), null, 'user.name() compatibility' );
+	assert.assertTrue( mw.user.isAnon(), 'user.isAnon() returns true when anonymous' );
+	assert.assertTrue( mw.user.anonymous(), 'user.anonymous() compatibility' );
 
 	// Not part of startUp module
 	mw.config.set( 'wgUserName', 'John' );
 
-	equal( mw.user.name(), 'John', 'user.name returns username when logged-in' );
-	ok( !mw.user.anonymous(), 'user.anonymous returns false when logged-in' );
+	assert.equal( mw.user.getName(), 'John', 'user.getName() returns username when logged-in' );
+	assert.equal( mw.user.name(), 'John', 'user.name() compatibility' );
+	assert.assertFalse( mw.user.isAnon(), 'user.isAnon() returns false when logged-in' );
+	assert.assertFalse( mw.user.anonymous(), 'user.anonymous() compatibility' );
 
-	equal( mw.user.id(), 'John', 'user.id Returns username when logged-in' );
+	assert.equal( mw.user.id(), 'John', 'user.id Returns username when logged-in' );
 });
+
+QUnit.asyncTest( 'getGroups', 3, function ( assert ) {
+	mw.user.getGroups( function ( groups ) {
+		// First group should always be '*'
+		assert.equal( $.type( groups ), 'array', 'Callback gets an array' );
+		assert.notStrictEqual( $.inArray( '*', groups ), -1, '"*"" is in the list' );
+		// Sort needed because of different methods if creating the arrays,
+		// only the content matters.
+		assert.deepEqual( groups.sort(), mw.config.get( 'wgUserGroups' ).sort(), 'Array contains all groups, just like wgUserGroups' );
+		QUnit.start();
+	});
+});
+
+QUnit.asyncTest( 'getRights', 1, function ( assert ) {
+	mw.user.getRights( function ( rights ) {
+		// First group should always be '*'
+		assert.equal( $.type( rights ), 'array', 'Callback gets an array' );
+		QUnit.start();
+	});
+});
+
+}( mediaWiki ) );
diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.util.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.util.test.js
index ea28935e..ababa8d9 100644
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.util.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.util.test.js
@@ -1,73 +1,58 @@
-module( 'mediawiki.util', QUnit.newMwEnvironment() );
+QUnit.module( 'mediawiki.util', QUnit.newMwEnvironment() );
 
-test( '-- Initial check', function() {
-	expect(1);
-
-	ok( mw.util, 'mw.util defined' );
-});
-
-test( 'rawurlencode', function() {
-	expect(1);
-
-	equal( mw.util.rawurlencode( 'Test:A & B/Here' ), 'Test%3AA%20%26%20B%2FHere' );
+QUnit.test( 'rawurlencode', 1, function ( assert ) {
+	assert.equal( mw.util.rawurlencode( 'Test:A & B/Here' ), 'Test%3AA%20%26%20B%2FHere' );
 });
 
-test( 'wikiUrlencode', function() {
-	expect(1);
-
-	equal( mw.util.wikiUrlencode( 'Test:A & B/Here' ), 'Test:A_%26_B/Here' );
+QUnit.test( 'wikiUrlencode', 1, function ( assert ) {
+	assert.equal( mw.util.wikiUrlencode( 'Test:A & B/Here' ), 'Test:A_%26_B/Here' );
 });
 
-test( 'wikiGetlink', function() {
-	expect(3);
-
+QUnit.test( 'wikiGetlink', 3, function ( assert ) {
 	// Not part of startUp module
 	mw.config.set( 'wgArticlePath', '/wiki/$1' );
 	mw.config.set( 'wgPageName', 'Foobar' );
 
 	var hrefA = mw.util.wikiGetlink( 'Sandbox' );
-	equal( hrefA, '/wiki/Sandbox', 'Simple title; Get link for "Sandbox"' );
+	assert.equal( hrefA, '/wiki/Sandbox', 'Simple title; Get link for "Sandbox"' );
 
 	var hrefB = mw.util.wikiGetlink( 'Foo:Sandbox ? 5+5=10 ! (test)/subpage' );
-	equal( hrefB, '/wiki/Foo:Sandbox_%3F_5%2B5%3D10_%21_%28test%29/subpage',
+	assert.equal( hrefB, '/wiki/Foo:Sandbox_%3F_5%2B5%3D10_%21_%28test%29/subpage',
 		'Advanced title; Get link for "Foo:Sandbox ? 5+5=10 ! (test)/subpage"' );
 
 	var hrefC = mw.util.wikiGetlink();
-	equal( hrefC, '/wiki/Foobar', 'Default title; Get link for current page ("Foobar")' );
+	assert.equal( hrefC, '/wiki/Foobar', 'Default title; Get link for current page ("Foobar")' );
 });
 
-test( 'wikiScript', function() {
-	expect(2);
-
+QUnit.test( 'wikiScript', 4, function ( assert ) {
 	mw.config.set({
-		'wgScript': '/w/index.php',
+		'wgScript': '/w/i.php', // customized wgScript for bug 39103
+		'wgLoadScript': '/w/l.php', // customized wgLoadScript for bug 39103
 		'wgScriptPath': '/w',
 		'wgScriptExtension': '.php'
 	});
 
-	equal( mw.util.wikiScript(), mw.config.get( 'wgScript' ), 'Defaults to index.php and is equal to wgScript' );
-	equal( mw.util.wikiScript( 'api' ), '/w/api.php', 'API path' );
+	assert.equal( mw.util.wikiScript(), mw.config.get( 'wgScript' ), 'wikiScript() returns wgScript' );
+	assert.equal( mw.util.wikiScript( 'index' ), mw.config.get( 'wgScript' ), "wikiScript( 'index' ) returns wgScript" );
+	assert.equal( mw.util.wikiScript( 'load' ), mw.config.get( 'wgLoadScript' ), "wikiScript( 'load' ) returns wgLoadScript" );
+	assert.equal( mw.util.wikiScript( 'api' ), '/w/api.php', 'API path' );
 });
 
-test( 'addCSS', function() {
-	expect(3);
-
+QUnit.test( 'addCSS', 3, function ( assert ) {
 	var $testEl = $( '<div>' ).attr( 'id', 'mw-addcsstest' ).appendTo( '#qunit-fixture' );
 
 	var style = mw.util.addCSS( '#mw-addcsstest { visibility: hidden; }' );
-	equal( typeof style, 'object', 'addCSS returned an object' );
-	strictEqual( style.disabled, false, 'property "disabled" is available and set to false' );
+	assert.equal( typeof style, 'object', 'addCSS returned an object' );
+	assert.strictEqual( style.disabled, false, 'property "disabled" is available and set to false' );
 
-	equal( $testEl.css( 'visibility' ), 'hidden', 'Added style properties are in effect' );
+	assert.equal( $testEl.css( 'visibility' ), 'hidden', 'Added style properties are in effect' );
 
 	// Clean up
 	$( style.ownerNode ).remove();
 });
 
-test( 'toggleToc', function() {
-	expect(4);
-
-	strictEqual( mw.util.toggleToc(), null, 'Return null if there is no table of contents on the page.' );
+QUnit.asyncTest( 'toggleToc', 4, function ( assert ) {
+	assert.strictEqual( mw.util.toggleToc(), null, 'Return null if there is no table of contents on the page.' );
 
 	var	tocHtml =
 	'<table id="toc" class="toc"><tr><td>' +
@@ -80,57 +65,46 @@ test( 'toggleToc', function() {
 		$toc = $(tocHtml).appendTo( '#qunit-fixture' ),
 		$toggleLink = $( '#togglelink' );
 
-	strictEqual( $toggleLink.length, 1, 'Toggle link is appended to the page.' );
-
-	// Toggle animation is asynchronous
-	// QUnit should not finish this test() untill they are all done
-	stop();
+	assert.strictEqual( $toggleLink.length, 1, 'Toggle link is appended to the page.' );
 
 	var actionC = function() {
-		start();
+		QUnit.start();
 	};
 	var actionB = function() {
-		start(); stop();
-		strictEqual( mw.util.toggleToc( $toggleLink, actionC ), true, 'Return boolean true if the TOC is now visible.' );
+		assert.strictEqual( mw.util.toggleToc( $toggleLink, actionC ), true, 'Return boolean true if the TOC is now visible.' );
 	};
 	var actionA = function() {
-		strictEqual( mw.util.toggleToc( $toggleLink, actionB ), false, 'Return boolean false if the TOC is now hidden.' );
+		assert.strictEqual( mw.util.toggleToc( $toggleLink, actionB ), false, 'Return boolean false if the TOC is now hidden.' );
 	};
 
 	actionA();
 });
 
-test( 'getParamValue', function() {
-	expect(5);
-
+QUnit.test( 'getParamValue', 5, function ( assert ) {
 	var	url1 = 'http://example.org/?foo=wrong&foo=right#&foo=bad';
 
-	equal( mw.util.getParamValue( 'foo', url1 ), 'right', 'Use latest one, ignore hash' );
-	strictEqual( mw.util.getParamValue( 'bar', url1 ), null, 'Return null when not found' );
+	assert.equal( mw.util.getParamValue( 'foo', url1 ), 'right', 'Use latest one, ignore hash' );
+	assert.strictEqual( mw.util.getParamValue( 'bar', url1 ), null, 'Return null when not found' );
 
 	var url2 = 'http://example.org/#&foo=bad';
-	strictEqual( mw.util.getParamValue( 'foo', url2 ), null, 'Ignore hash if param is not in querystring but in hash (bug 27427)' );
+	assert.strictEqual( mw.util.getParamValue( 'foo', url2 ), null, 'Ignore hash if param is not in querystring but in hash (bug 27427)' );
 
 	var url3 = 'example.org?' + $.param({ 'TEST': 'a b+c' });
-	strictEqual( mw.util.getParamValue( 'TEST', url3 ), 'a b+c', 'Bug 30441: getParamValue must understand "+" encoding of space' );
+	assert.strictEqual( mw.util.getParamValue( 'TEST', url3 ), 'a b+c', 'Bug 30441: getParamValue must understand "+" encoding of space' );
 
 	var url4 = 'example.org?' + $.param({ 'TEST': 'a b+c d' }); // check for sloppy code from r95332 :)
-	strictEqual( mw.util.getParamValue( 'TEST', url4 ), 'a b+c d', 'Bug 30441: getParamValue must understand "+" encoding of space (multiple spaces)' );
+	assert.strictEqual( mw.util.getParamValue( 'TEST', url4 ), 'a b+c d', 'Bug 30441: getParamValue must understand "+" encoding of space (multiple spaces)' );
 });
 
-test( 'tooltipAccessKey', function() {
-	expect(3);
-
-	equal( typeof mw.util.tooltipAccessKeyPrefix, 'string', 'mw.util.tooltipAccessKeyPrefix must be a string' );
-	ok( mw.util.tooltipAccessKeyRegexp instanceof RegExp, 'mw.util.tooltipAccessKeyRegexp instance of RegExp' );
-	ok( mw.util.updateTooltipAccessKeys, 'mw.util.updateTooltipAccessKeys' );
+QUnit.test( 'tooltipAccessKey', 3, function ( assert ) {
+	assert.equal( typeof mw.util.tooltipAccessKeyPrefix, 'string', 'mw.util.tooltipAccessKeyPrefix must be a string' );
+	assert.ok( mw.util.tooltipAccessKeyRegexp instanceof RegExp, 'mw.util.tooltipAccessKeyRegexp instance of RegExp' );
+	assert.ok( mw.util.updateTooltipAccessKeys, 'mw.util.updateTooltipAccessKeys' );
 });
 
-test( '$content', function() {
-	expect(2);
-
-	ok( mw.util.$content instanceof jQuery, 'mw.util.$content instance of jQuery' );
-	strictEqual( mw.util.$content.length, 1, 'mw.util.$content must have length of 1' );
+QUnit.test( '$content', 2, function ( assert ) {
+	assert.ok( mw.util.$content instanceof jQuery, 'mw.util.$content instance of jQuery' );
+	assert.strictEqual( mw.util.$content.length, 1, 'mw.util.$content must have length of 1' );
 });
 
 
@@ -138,87 +112,98 @@ test( '$content', function() {
  * Portlet names are prefixed with 'p-test' to avoid conflict with core
  * when running the test suite under a wiki page.
  * Previously, test elements where invisible to the selector since only
- * one element can have a given id. 
+ * one element can have a given id.
  */
-test( 'addPortletLink', function() {
-	expect(7);
-
-	var mwPanel = '<div id="mw-panel" class="noprint">\
-	<h5>Toolbox</h5>\
+QUnit.test( 'addPortletLink', 8, function ( assert ) {
+	var pTestTb, pCustom, vectorTabs, tbRL, cuQuux, $cuQuux, tbMW, $tbMW, tbRLDM, caFoo;
+	pTestTb = '\
 	<div class="portlet" id="p-test-tb">\
+		<h5>Toolbox</h5>\
 		<ul class="body"></ul>\
-	</div>\
-</div>',
-	vectorTabs = '<div id="p-test-views" class="vectorTabs">\
-	<h5>Views</h5>\
-	<ul></ul>\
-</div>',
-	$mwPanel = $(mwPanel).appendTo( '#qunit-fixture' ),
-	$vectorTabs = $(vectorTabs).appendTo( '#qunit-fixture' );
-
-	var tbRL = mw.util.addPortletLink( 'p-test-tb', '//mediawiki.org/wiki/ResourceLoader',
+	</div>';
+	pCustom = '\
+	<div class="portlet" id="p-test-custom">\
+		<h5>Views</h5>\
+		<ul class="body">\
+			<li id="c-foo"><a href="#">Foo</a></li>\
+			<li id="c-barmenu">\
+				<ul>\
+					<li id="c-bar-baz"><a href="#">Baz</a></a>\
+				</ul>\
+			</li>\
+		</ul>\
+	</div>';
+	vectorTabs = '\
+	<div id="p-test-views" class="vectorTabs">\
+		<h5>Views</h5>\
+		<ul></ul>\
+	</div>';
+
+	$( '#qunit-fixture' ).append( pTestTb, pCustom, vectorTabs );
+
+	tbRL = mw.util.addPortletLink( 'p-test-tb', '//mediawiki.org/wiki/ResourceLoader',
 		'ResourceLoader', 't-rl', 'More info about ResourceLoader on MediaWiki.org ', 'l' );
 
-	ok( $.isDomElement( tbRL ), 'addPortletLink returns a valid DOM Element according to $.isDomElement' );
+	assert.ok( $.isDomElement( tbRL ), 'addPortletLink returns a valid DOM Element according to $.isDomElement' );
 
-	var	tbMW = mw.util.addPortletLink( 'p-test-tb', '//mediawiki.org/',
-			'MediaWiki.org', 't-mworg', 'Go to MediaWiki.org ', 'm', tbRL ),
-		$tbMW = $( tbMW );
+	tbMW = mw.util.addPortletLink( 'p-test-tb', '//mediawiki.org/',
+		'MediaWiki.org', 't-mworg', 'Go to MediaWiki.org ', 'm', tbRL );
+	$tbMW = $( tbMW );
 
 
-	equal( $tbMW.attr( 'id' ), 't-mworg', 'Link has correct ID set' );
-	equal( $tbMW.closest( '.portlet' ).attr( 'id' ), 'p-test-tb', 'Link was inserted within correct portlet' );
-	equal( $tbMW.next().attr( 'id' ), 't-rl', 'Link is in the correct position (by passing nextnode)' );
+	assert.equal( $tbMW.attr( 'id' ), 't-mworg', 'Link has correct ID set' );
+	assert.equal( $tbMW.closest( '.portlet' ).attr( 'id' ), 'p-test-tb', 'Link was inserted within correct portlet' );
+	assert.equal( $tbMW.next().attr( 'id' ), 't-rl', 'Link is in the correct position (by passing nextnode)' );
 
-	var tbRLDM = mw.util.addPortletLink( 'p-test-tb', '//mediawiki.org/wiki/RL/DM',
-		'Default modules', 't-rldm', 'List of all default modules ', 'd', '#t-rl' );
+	cuQuux = mw.util.addPortletLink( 'p-test-custom', '#', 'Quux' );
+	$cuQuux = $(cuQuux);
 
-	equal( $( tbRLDM ).next().attr( 'id' ), 't-rl', 'Link is in the correct position (by passing CSS selector)' );
+	assert.equal(
+		$( '#p-test-custom #c-barmenu ul li' ).length,
+		1,
+		'addPortletLink did not add the item to all <ul> elements in the portlet (bug 35082)'
+	);
 
-	var caFoo = mw.util.addPortletLink( 'p-test-views', '#', 'Foo' );
+	tbRLDM = mw.util.addPortletLink( 'p-test-tb', '//mediawiki.org/wiki/RL/DM',
+		'Default modules', 't-rldm', 'List of all default modules ', 'd', '#t-rl' );
 
-	strictEqual( $tbMW.find( 'span').length, 0, 'No <span> element should be added for porlets without vectorTabs class.' );
-	strictEqual( $( caFoo ).find( 'span').length, 1, 'A <span> element should be added for porlets with vectorTabs class.' );
+	assert.equal( $( tbRLDM ).next().attr( 'id' ), 't-rl', 'Link is in the correct position (by passing CSS selector)' );
 
-	// Clean up
-	$( [tbRL, tbMW, tbRLDM, caFoo] ).remove();
-});
+	caFoo = mw.util.addPortletLink( 'p-test-views', '#', 'Foo' );
 
-test( 'jsMessage', function() {
-	expect(1);
+	assert.strictEqual( $tbMW.find( 'span').length, 0, 'No <span> element should be added for porlets without vectorTabs class.' );
+	assert.strictEqual( $( caFoo ).find( 'span').length, 1, 'A <span> element should be added for porlets with vectorTabs class.' );
+});
 
+QUnit.test( 'jsMessage', 1, function ( assert ) {
 	var a = mw.util.jsMessage( "MediaWiki is <b>Awesome</b>." );
-	ok( a, 'Basic checking of return value' );
+	assert.ok( a, 'Basic checking of return value' );
 
 	// Clean up
 	$( '#mw-js-message' ).remove();
 });
 
-test( 'validateEmail', function() {
-	expect(6);
-
-	strictEqual( mw.util.validateEmail( "" ), null, 'Should return null for empty string ' );
-	strictEqual( mw.util.validateEmail( "user@localhost" ), true, 'Return true for a valid e-mail address' );
+QUnit.test( 'validateEmail', 6, function ( assert ) {
+	assert.strictEqual( mw.util.validateEmail( "" ), null, 'Should return null for empty string ' );
+	assert.strictEqual( mw.util.validateEmail( "user@localhost" ), true, 'Return true for a valid e-mail address' );
 
 	// testEmailWithCommasAreInvalids
-	strictEqual( mw.util.validateEmail( "user,foo@example.org" ), false, 'Emails with commas are invalid' );
-	strictEqual( mw.util.validateEmail( "userfoo@ex,ample.org" ), false, 'Emails with commas are invalid' );
+	assert.strictEqual( mw.util.validateEmail( "user,foo@example.org" ), false, 'Emails with commas are invalid' );
+	assert.strictEqual( mw.util.validateEmail( "userfoo@ex,ample.org" ), false, 'Emails with commas are invalid' );
 
 	// testEmailWithHyphens
-	strictEqual( mw.util.validateEmail( "user-foo@example.org" ), true, 'Emails may contain a hyphen' );
-	strictEqual( mw.util.validateEmail( "userfoo@ex-ample.org" ), true, 'Emails may contain a hyphen' );
+	assert.strictEqual( mw.util.validateEmail( "user-foo@example.org" ), true, 'Emails may contain a hyphen' );
+	assert.strictEqual( mw.util.validateEmail( "userfoo@ex-ample.org" ), true, 'Emails may contain a hyphen' );
 });
 
-test( 'isIPv6Address', function() {
-	expect(40);
-
+QUnit.test( 'isIPv6Address', 40, function ( assert ) {
 	// Shortcuts
-	var	assertFalseIPv6 = function( addy, summary ) {
-			return strictEqual( mw.util.isIPv6Address( addy ), false, summary );
-		},
-		assertTrueIPv6 = function( addy, summary ) {
-			return strictEqual( mw.util.isIPv6Address( addy ), true, summary );
-		};
+	function assertFalseIPv6( addy, summary ) {
+		return assert.strictEqual( mw.util.isIPv6Address( addy ), false, summary );
+	}
+	function assertTrueIPv6( addy, summary ) {
+		return assert.strictEqual( mw.util.isIPv6Address( addy ), true, summary );
+	}
 
 	// Based on IPTest.php > testisIPv6
 	assertFalseIPv6( ':fc:100::', 'IPv6 starting with lone ":"' );
@@ -232,7 +217,7 @@ test( 'isIPv6Address', function() {
 	'fc:100:a:d::',
 	'fc:100:a:d:1::',
 	'fc:100:a:d:1:e::',
-	'fc:100:a:d:1:e:ac::'], function( i, addy ){
+	'fc:100:a:d:1:e:ac::'], function ( i, addy ){
 		assertTrueIPv6( addy, addy + ' is a valid IP' );
 	});
 
@@ -253,7 +238,7 @@ test( 'isIPv6Address', function() {
 	'::fc:100:a:d:1:e',
 	'::fc:100:a:d:1:e:ac',
 
-	'fc:100:a:d:1:e:ac:0'], function( i, addy ){
+	'fc:100:a:d:1:e:ac:0'], function ( i, addy ){
 		assertTrueIPv6( addy, addy + ' is a valid IP' );
 	});
 
@@ -278,16 +263,14 @@ test( 'isIPv6Address', function() {
 	assertFalseIPv6( 'fc::100:a:d:1:e:ac:0:1', 'IPv6 with 9 words' );
 });
 
-test( 'isIPv4Address', function() {
-	expect(11);
-
+QUnit.test( 'isIPv4Address', 11, function ( assert ) {
 	// Shortcuts
-	var	assertFalseIPv4 = function( addy, summary ) {
-			return strictEqual( mw.util.isIPv4Address( addy ), false, summary );
-		},
-		assertTrueIPv4 = function( addy, summary ) {
-			return strictEqual( mw.util.isIPv4Address( addy ), true, summary );
-		};
+	function assertFalseIPv4( addy, summary ) {
+		assert.strictEqual( mw.util.isIPv4Address( addy ), false, summary );
+	}
+	function assertTrueIPv4( addy, summary ) {
+		assert.strictEqual( mw.util.isIPv4Address( addy ), true, summary );
+	}
 
 	// Based on IPTest.php > testisIPv4
 	assertFalseIPv4( false, 'Boolean false is not an IP' );