Widget: Shift to use no globals

4 files changed, 457 insertions, 445 deletions

diff --git a/tests/unit/widget/animation.js b/tests/unit/widget/animation.js
index 9f9f92710..bbd3ca854 100644
--- a/tests/unit/widget/animation.js
+++ b/tests/unit/widget/animation.js
@@ -1,14 +1,15 @@
 define( [
+	"qunit",
 	"jquery",
 	"ui/widget"
-], function( $ ) {
+], function( QUnit, $ ) {
 
-module( "widget animation", ( function() {
+QUnit.module( "widget animation", ( function() {
 	var show = $.fn.show,
 		fadeIn = $.fn.fadeIn,
 		slideDown = $.fn.slideDown;
 	return {
-		setup: function() {
+		beforeEach: function() {
 			$.widget( "ui.testWidget", {
 				_create: function() {
 					this.element.hide();
@@ -19,7 +20,7 @@ module( "widget animation", ( function() {
 			} );
 			$.effects = { effect: { testEffect: $.noop } };
 		},
-		teardown: function() {
+		afterEach: function() {
 			delete $.ui.testWidget;
 			delete $.effects.effect.testEffect;
 			$.fn.show = show;
@@ -29,34 +30,36 @@ module( "widget animation", ( function() {
 	};
 }() ) );
 
-asyncTest( "show: null", function() {
-	expect( 4 );
+QUnit.test( "show: null", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 4 );
 
 	var element = $( "#widget" ).testWidget(),
 		hasRun = false;
 	$.fn.show = function() {
-		ok( true, "show called" );
-		equal( arguments.length, 0, "no args passed to show" );
+		assert.ok( true, "show called" );
+		assert.equal( arguments.length, 0, "no args passed to show" );
 	};
 
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
 
-asyncTest( "show: true", function() {
-	expect( 4 );
+QUnit.test( "show: true", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 4 );
 
 	var element = $( "#widget" ).testWidget( {
 			show: true
@@ -64,8 +67,8 @@ asyncTest( "show: true", function() {
 		hasRun = false;
 	$.fn.fadeIn = function( duration, easing, complete ) {
 		return this.queue( function( next ) {
-			strictEqual( duration, undefined, "duration" );
-			strictEqual( easing, undefined, "easing" );
+			assert.strictEqual( duration, undefined, "duration" );
+			assert.strictEqual( easing, undefined, "easing" );
 			complete();
 			next();
 		} );
@@ -74,21 +77,22 @@ asyncTest( "show: true", function() {
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
 
-asyncTest( "show: number", function() {
-	expect( 4 );
+QUnit.test( "show: number", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 4 );
 
 	var element = $( "#widget" ).testWidget( {
 		show: 123
@@ -96,8 +100,8 @@ asyncTest( "show: number", function() {
 	hasRun = false;
 	$.fn.fadeIn = function( duration, easing, complete ) {
 		return this.queue( function( next ) {
-			strictEqual( duration, 123, "duration" );
-			strictEqual( easing, undefined, "easing" );
+			assert.strictEqual( duration, 123, "duration" );
+			assert.strictEqual( easing, undefined, "easing" );
 			complete();
 			next();
 		} );
@@ -106,21 +110,22 @@ asyncTest( "show: number", function() {
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
 
-asyncTest( "show: core animation", function() {
-	expect( 4 );
+QUnit.test( "show: core animation", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 4 );
 
 	var element = $( "#widget" ).testWidget( {
 		show: "slideDown"
@@ -128,8 +133,8 @@ asyncTest( "show: core animation", function() {
 	hasRun = false;
 	$.fn.slideDown = function( duration, easing, complete ) {
 		return this.queue( function( next ) {
-			strictEqual( duration, undefined, "duration" );
-			strictEqual( easing, undefined, "easing" );
+			assert.strictEqual( duration, undefined, "duration" );
+			assert.strictEqual( easing, undefined, "easing" );
 			complete();
 			next();
 		} );
@@ -138,21 +143,22 @@ asyncTest( "show: core animation", function() {
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
 
-asyncTest( "show: effect", function() {
-	expect( 5 );
+QUnit.test( "show: effect", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 5 );
 
 	var element = $( "#widget" ).testWidget( {
 		show: "testEffect"
@@ -160,9 +166,9 @@ asyncTest( "show: effect", function() {
 	hasRun = false;
 	$.fn.show = function( options ) {
 		return this.queue( function( next ) {
-			equal( options.effect, "testEffect", "effect" );
-			ok( !( "duration" in options ), "duration" );
-			ok( !( "easing" in options ), "easing" );
+			assert.equal( options.effect, "testEffect", "effect" );
+			assert.ok( !( "duration" in options ), "duration" );
+			assert.ok( !( "easing" in options ), "easing" );
 			options.complete();
 			next();
 		} );
@@ -171,21 +177,22 @@ asyncTest( "show: effect", function() {
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
 
-asyncTest( "show: object(core animation)", function() {
-	expect( 4 );
+QUnit.test( "show: object(core animation)", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 4 );
 
 	var element = $( "#widget" ).testWidget( {
 		show: {
@@ -197,8 +204,8 @@ asyncTest( "show: object(core animation)", function() {
 	hasRun = false;
 	$.fn.slideDown = function( duration, easing, complete ) {
 		return this.queue( function( next ) {
-			equal( duration, 123, "duration" );
-			equal( easing, "testEasing", "easing" );
+			assert.equal( duration, 123, "duration" );
+			assert.equal( easing, "testEasing", "easing" );
 			complete();
 			next();
 		} );
@@ -207,21 +214,22 @@ asyncTest( "show: object(core animation)", function() {
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
 
-asyncTest( "show: object(effect)", function() {
-	expect( 3 );
+QUnit.test( "show: object(effect)", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 3 );
 
 	var element = $( "#widget" ).testWidget( {
 		show: {
@@ -233,7 +241,7 @@ asyncTest( "show: object(effect)", function() {
 	hasRun = false;
 	$.fn.show = function( options ) {
 		return this.queue( function( next ) {
-			deepEqual( options, {
+			assert.deepEqual( options, {
 				effect: "testEffect",
 				duration: 123,
 				easing: "testEasing",
@@ -247,15 +255,15 @@ asyncTest( "show: object(effect)", function() {
 	element
 		.delay( 50 )
 		.queue( function( next ) {
-			ok( !hasRun, "queue before show" );
+			assert.ok( !hasRun, "queue before show" );
 			next();
 		} )
 		.testWidget( "show", function() {
 			hasRun = true;
 		} )
 		.queue( function( next ) {
-			ok( hasRun, "queue after show" );
-			start();
+			assert.ok( hasRun, "queue after show" );
+			ready();
 			next();
 		} );
 } );
diff --git a/tests/unit/widget/classes.js b/tests/unit/widget/classes.js
index b837aac34..d355c3a36 100644
--- a/tests/unit/widget/classes.js
+++ b/tests/unit/widget/classes.js
@@ -1,10 +1,11 @@
 define( [
+	"qunit",
 	"jquery",
 	"ui/widget"
-], function( $ ) {
+], function( QUnit, $ ) {
 
-module( "widget factory classes", {
-	setup: function() {
+QUnit.module( "widget factory classes", {
+	beforeEach: function() {
 		$.widget( "ui.classesWidget", {
 			options: {
 				classes: {
@@ -50,7 +51,7 @@ module( "widget factory classes", {
 			}
 		} );
 	},
-	teardown: function() {
+	afterEach: function() {
 		delete $.ui.classesWidget;
 		delete $.fn.classesWidget;
 	}
@@ -89,8 +90,8 @@ function elementLacksClasses( widget, method, assert ) {
 		"_" + method + "Class works with ( element, keys, null" + toggle + " )" );
 }
 
-test( ".option() - classes setter", function( assert ) {
-	expect( 11 );
+QUnit.test( ".option() - classes setter", function( assert ) {
+	assert.expect( 11 );
 
 	var testWidget = $.ui.classesWidget();
 
@@ -118,16 +119,16 @@ test( ".option() - classes setter", function( assert ) {
 		"Appending a class to the current value works as expected" );
 } );
 
-test( ".destroy() - class removal", function( assert ) {
-	expect( 1 );
+QUnit.test( ".destroy() - class removal", function( assert ) {
+	assert.expect( 1 );
 
 	assert.domEqual( "#widget", function() {
 		$( "#widget" ).classesWidget().classesWidget( "destroy" );
 	} );
 } );
 
-test( "._add/_remove/_toggleClass()", function( assert ) {
-	expect( 24 );
+QUnit.test( "._add/_remove/_toggleClass()", function( assert ) {
+	assert.expect( 24 );
 
 	var widget = $( "#widget" ).classesWidget();
 
diff --git a/tests/unit/widget/core.js b/tests/unit/widget/core.js
index 93bfe875a..00dcb1611 100644
--- a/tests/unit/widget/core.js
+++ b/tests/unit/widget/core.js
@@ -1,11 +1,12 @@
 define( [
+	"qunit",
 	"jquery",
 	"lib/common",
 	"ui/widget"
-], function( $, common ) {
+], function( QUnit, $, common ) {
 
-module( "widget factory", {
-	teardown: function() {
+QUnit.module( "widget factory", {
+	afterEach: function() {
 		if ( $.ui ) {
 			delete $.ui.testWidget;
 			delete $.fn.testWidget;
@@ -15,92 +16,92 @@ module( "widget factory", {
 
 common.testJshint( "widget" );
 
-test( "widget creation", function() {
-	expect( 5 );
+QUnit.test( "widget creation", function( assert ) {
+	assert.expect( 5 );
 	var method,
 		myPrototype = {
 			_create: function() {
-				equal( method, "_create", "create function is copied over" );
+				assert.equal( method, "_create", "create function is copied over" );
 			},
 			creationTest: function() {
-				equal( method, "creationTest", "random function is copied over" );
+				assert.equal( method, "creationTest", "random function is copied over" );
 			}
 		};
 
 	$.widget( "ui.testWidget", myPrototype );
-	ok( $.isFunction( $.ui.testWidget ), "constructor was created" );
-	equal( typeof $.ui.testWidget.prototype, "object", "prototype was created" );
+	assert.ok( $.isFunction( $.ui.testWidget ), "constructor was created" );
+	assert.equal( typeof $.ui.testWidget.prototype, "object", "prototype was created" );
 	method = "_create";
 	$.ui.testWidget.prototype._create();
 	method = "creationTest";
 	$.ui.testWidget.prototype.creationTest();
-	equal( $.ui.testWidget.prototype.option, $.Widget.prototype.option,
+	assert.equal( $.ui.testWidget.prototype.option, $.Widget.prototype.option,
 		"option method copied over from base widget" );
 } );
 
-test( "element normalization", function() {
-	expect( 11 );
+QUnit.test( "element normalization", function( assert ) {
+	assert.expect( 11 );
 	var elem;
 	$.widget( "ui.testWidget", {} );
 
 	$.ui.testWidget.prototype._create = function() {
 
-		// workaround for core ticket #8381
+		// Workaround for core ticket #8381
 		this.element.appendTo( "#qunit-fixture" );
-		ok( this.element.is( "div" ), "generated div" );
-		deepEqual( this.element.testWidget( "instance" ), this, "instance stored in .data()" );
+		assert.ok( this.element.is( "div" ), "generated div" );
+		assert.deepEqual( this.element.testWidget( "instance" ), this, "instance stored in .data()" );
 	};
 	$.ui.testWidget();
 
 	$.ui.testWidget.prototype.defaultElement = "<span data-test='pass'></span>";
 	$.ui.testWidget.prototype._create = function() {
-		ok( this.element.is( "span[data-test=pass]" ), "generated span with properties" );
-		deepEqual( this.element.testWidget( "instance" ), this, "instance stored in .data()" );
+		assert.ok( this.element.is( "span[data-test=pass]" ), "generated span with properties" );
+		assert.deepEqual( this.element.testWidget( "instance" ), this, "instance stored in .data()" );
 	};
 	$.ui.testWidget();
 
 	elem = $( "<input>" );
 	$.ui.testWidget.prototype._create = function() {
-		deepEqual( this.element[ 0 ], elem[ 0 ], "from element" );
-		deepEqual( elem.testWidget( "instance" ), this, "instance stored in .data()" );
+		assert.deepEqual( this.element[ 0 ], elem[ 0 ], "from element" );
+		assert.deepEqual( elem.testWidget( "instance" ), this, "instance stored in .data()" );
 	};
 	$.ui.testWidget( {}, elem[ 0 ] );
 
 	elem = $( "<div>" );
 	$.ui.testWidget.prototype._create = function() {
-		deepEqual( this.element[ 0 ], elem[ 0 ], "from jQuery object" );
-		deepEqual( elem.testWidget( "instance" ), this, "instance stored in .data()" );
+		assert.deepEqual( this.element[ 0 ], elem[ 0 ], "from jQuery object" );
+		assert.deepEqual( elem.testWidget( "instance" ), this, "instance stored in .data()" );
 	};
 	$.ui.testWidget( {}, elem );
 
 	elem = $( "<div id='element-normalization-selector'></div>" )
 		.appendTo( "#qunit-fixture" );
 	$.ui.testWidget.prototype._create = function() {
-		deepEqual( this.element[ 0 ], elem[ 0 ], "from selector" );
-		deepEqual( elem.testWidget( "instance" ), this, "instance stored in .data()" );
+		assert.deepEqual( this.element[ 0 ], elem[ 0 ], "from selector" );
+		assert.deepEqual( elem.testWidget( "instance" ), this, "instance stored in .data()" );
 	};
 	$.ui.testWidget( {}, "#element-normalization-selector" );
 
 	$.ui.testWidget.prototype.defaultElement = null;
 	$.ui.testWidget.prototype._create = function() {
 
-		// using strictEqual throws an error (Maximum call stack size exceeded)
-		ok( this.element[ 0 ] === this, "instance as element" );
+		// Using strictEqual throws an error (Maximum call stack size exceeded)
+		assert.ok( this.element[ 0 ] === this, "instance as element" );
 	};
 	$.ui.testWidget();
 } );
 
-test( "custom selector expression", function() {
-	expect( 1 );
+QUnit.test( "custom selector expression", function( assert ) {
+	assert.expect( 1 );
 	var elem = $( "<div>" ).appendTo( "#qunit-fixture" );
 	$.widget( "ui.testWidget", {} );
 	elem.testWidget();
-	deepEqual( $( ":ui-testwidget" )[ 0 ], elem[ 0 ] );
+	assert.deepEqual( $( ":ui-testwidget" )[ 0 ], elem[ 0 ] );
 	elem.testWidget( "destroy" );
 } );
 
-test( "jQuery usage", function() {
-	expect( 14 );
+QUnit.test( "jQuery usage", function( assert ) {
+	assert.expect( 14 );
 
 	var elem, instance, ret,
 		shouldCreate = false;
@@ -108,13 +109,13 @@ test( "jQuery usage", function() {
 	$.widget( "ui.testWidget", {
 		getterSetterVal: 5,
 		_create: function() {
-			ok( shouldCreate, "create called on instantiation" );
+			assert.ok( shouldCreate, "create called on instantiation" );
 		},
 		methodWithParams: function( param1, param2 ) {
-			ok( true, "method called via .pluginName(methodName)" );
-			equal( param1, "value1",
+			assert.ok( true, "method called via .pluginName(methodName)" );
+			assert.equal( param1, "value1",
 				"parameter passed via .pluginName(methodName, param)" );
-			equal( param2, "value2",
+			assert.equal( param2, "value2",
 				"multiple parameters passed via .pluginName(methodName, param, param)" );
 
 			return this;
@@ -134,32 +135,32 @@ test( "jQuery usage", function() {
 	shouldCreate = true;
 	elem = $( "<div>" )
 		.on( "testwidgetcreate", function() {
-			ok( shouldCreate, "create event triggered on instantiation" );
+			assert.ok( shouldCreate, "create event triggered on instantiation" );
 		} )
 		.testWidget();
 	shouldCreate = false;
 
 	instance = elem.testWidget( "instance" );
-	equal( typeof instance, "object", "instance stored in .data(pluginName)" );
-	equal( instance.element[ 0 ], elem[ 0 ], "element stored on widget" );
+	assert.equal( typeof instance, "object", "instance stored in .data(pluginName)" );
+	assert.equal( instance.element[ 0 ], elem[ 0 ], "element stored on widget" );
 	ret = elem.testWidget( "methodWithParams", "value1", "value2" );
-	equal( ret, elem, "jQuery object returned from method call" );
+	assert.equal( ret, elem, "jQuery object returned from method call" );
 
 	ret = elem.testWidget( "getterSetterMethod" );
-	equal( ret, 5, "getter/setter can act as getter" );
+	assert.equal( ret, 5, "getter/setter can act as getter" );
 	ret = elem.testWidget( "getterSetterMethod", 30 );
-	equal( ret, elem, "getter/setter method can be chainable" );
-	equal( instance.getterSetterVal, 30, "getter/setter can act as setter" );
+	assert.equal( ret, elem, "getter/setter method can be chainable" );
+	assert.equal( instance.getterSetterVal, 30, "getter/setter can act as setter" );
 	ret = elem.testWidget( "jQueryObject" );
-	equal( ret[ 0 ], document.body, "returned jQuery object" );
-	equal( ret.end(), elem, "stack preserved" );
+	assert.equal( ret[ 0 ], document.body, "returned jQuery object" );
+	assert.equal( ret.end(), elem, "stack preserved" );
 
 	elem.testWidget( "destroy" );
-	equal( elem.testWidget( "instance" ), null );
+	assert.equal( elem.testWidget( "instance" ), null );
 } );
 
-test( "direct usage", function() {
-	expect( 9 );
+QUnit.test( "direct usage", function( assert ) {
+	assert.expect( 9 );
 
 	var elem, instance, ret,
 		shouldCreate = false;
@@ -167,12 +168,12 @@ test( "direct usage", function() {
 	$.widget( "ui.testWidget", {
 		getterSetterVal: 5,
 		_create: function() {
-			ok( shouldCreate, "create called on instantiation" );
+			assert.ok( shouldCreate, "create called on instantiation" );
 		},
 		methodWithParams: function( param1, param2 ) {
-			ok( true, "method called dirctly" );
-			equal( param1, "value1", "parameter passed via direct call" );
-			equal( param2, "value2", "multiple parameters passed via direct call" );
+			assert.ok( true, "method called dirctly" );
+			assert.equal( param1, "value1", "parameter passed via direct call" );
+			assert.equal( param2, "value2", "multiple parameters passed via direct call" );
 
 			return this;
 		},
@@ -191,48 +192,48 @@ test( "direct usage", function() {
 	instance = new $.ui.testWidget( {}, elem );
 	shouldCreate = false;
 
-	equal( $( elem ).testWidget( "instance" ), instance,
+	assert.equal( $( elem ).testWidget( "instance" ), instance,
 		"instance stored in .data(pluginName)" );
-	equal( instance.element[ 0 ], elem, "element stored on widget" );
+	assert.equal( instance.element[ 0 ], elem, "element stored on widget" );
 
 	ret = instance.methodWithParams( "value1", "value2" );
-	equal( ret, instance, "plugin returned from method call" );
+	assert.equal( ret, instance, "plugin returned from method call" );
 
 	ret = instance.getterSetterMethod();
-	equal( ret, 5, "getter/setter can act as getter" );
+	assert.equal( ret, 5, "getter/setter can act as getter" );
 	instance.getterSetterMethod( 30 );
-	equal( instance.getterSetterVal, 30, "getter/setter can act as setter" );
+	assert.equal( instance.getterSetterVal, 30, "getter/setter can act as setter" );
 } );
 
-test( "error handling", function() {
-	expect( 3 );
+QUnit.test( "error handling", function( assert ) {
+	assert.expect( 3 );
 	var error = $.error;
 	$.widget( "ui.testWidget", {
 		_privateMethod: function() {}
 	} );
 	$.error = function( msg ) {
-		equal( msg, "cannot call methods on testWidget prior to initialization; " +
+		assert.equal( msg, "cannot call methods on testWidget prior to initialization; " +
 			"attempted to call method 'missing'", "method call before init" );
 	};
 	$( "<div>" ).testWidget( "missing" );
 	$.error = function( msg ) {
-		equal( msg, "no such method 'missing' for testWidget widget instance",
+		assert.equal( msg, "no such method 'missing' for testWidget widget instance",
 			"invalid method call on widget instance" );
 	};
 	$( "<div>" ).testWidget().testWidget( "missing" );
 	$.error = function( msg ) {
-		equal( msg, "no such method '_privateMethod' for testWidget widget instance",
+		assert.equal( msg, "no such method '_privateMethod' for testWidget widget instance",
 			"invalid method call on widget instance" );
 	};
 	$( "<div>" ).testWidget().testWidget( "_privateMethod" );
 	$.error = error;
 } );
 
-test( "merge multiple option arguments", function() {
-	expect( 1 );
+QUnit.test( "merge multiple option arguments", function( assert ) {
+	assert.expect( 1 );
 	$.widget( "ui.testWidget", {
 		_create: function() {
-			deepEqual( this.options, {
+			assert.deepEqual( this.options, {
 				classes: {},
 				create: null,
 				disabled: false,
@@ -266,8 +267,8 @@ test( "merge multiple option arguments", function() {
 	} );
 } );
 
-test( "._getCreateOptions()", function() {
-	expect( 4 );
+QUnit.test( "._getCreateOptions()", function( assert ) {
+	assert.expect( 4 );
 	$.widget( "ui.testWidget", {
 		options: {
 			option1: "valuex",
@@ -277,12 +278,12 @@ test( "._getCreateOptions()", function() {
 		_getCreateOptions: function() {
 			var superOptions = this._super();
 
-			deepEqual( superOptions, {}, "Base implementation returns empty object" );
+			assert.deepEqual( superOptions, {}, "Base implementation returns empty object" );
 
 			// Support: IE8
 			// Strict equality fails when comparing this.window in ie8
-			equal( this.window[ 0 ], window, "this.window is properly defined" );
-			strictEqual( this.document[ 0 ], document, "this.document is properly defined" );
+			assert.equal( this.window[ 0 ], window, "this.window is properly defined" );
+			assert.strictEqual( this.document[ 0 ], document, "this.document is properly defined" );
 
 			return {
 				option1: "override1",
@@ -290,7 +291,7 @@ test( "._getCreateOptions()", function() {
 			};
 		},
 		_create: function() {
-			deepEqual( this.options, {
+			assert.deepEqual( this.options, {
 				classes: {},
 				create: null,
 				disabled: false,
@@ -303,8 +304,8 @@ test( "._getCreateOptions()", function() {
 	$( "<div>" ).testWidget( { option2: "value2" } );
 } );
 
-test( "._getCreateEventData()", function() {
-	expect( 1 );
+QUnit.test( "._getCreateEventData()", function( assert ) {
+	assert.expect( 1 );
 	var data = { foo: "bar" };
 	$.widget( "ui.testWidget", {
 		_getCreateEventData: function() {
@@ -313,13 +314,13 @@ test( "._getCreateEventData()", function() {
 	} );
 	$( "<div>" ).testWidget( {
 		create: function( event, ui ) {
-			strictEqual( ui, data, "event data" );
+			assert.strictEqual( ui, data, "event data" );
 		}
 	} );
 } );
 
-test( "re-init", function() {
-	expect( 3 );
+QUnit.test( "re-init", function( assert ) {
+	assert.expect( 3 );
 	var div = $( "<div>" ),
 		actions = [];
 
@@ -337,29 +338,29 @@ test( "re-init", function() {
 
 	actions = [];
 	div.testWidget( { foo: "bar" } );
-	deepEqual( actions, [ "create", "init" ], "correct methods called on init" );
+	assert.deepEqual( actions, [ "create", "init" ], "correct methods called on init" );
 
 	actions = [];
 	div.testWidget();
-	deepEqual( actions, [ "init" ], "correct methods call on re-init" );
+	assert.deepEqual( actions, [ "init" ], "correct methods call on re-init" );
 
 	actions = [];
 	div.testWidget( { foo: "bar" } );
-	deepEqual( actions, [ "optionfoo", "init" ], "correct methods called on re-init with options" );
+	assert.deepEqual( actions, [ "optionfoo", "init" ], "correct methods called on re-init with options" );
 } );
 
-test( "redeclare", function() {
-	expect( 2 );
+QUnit.test( "redeclare", function( assert ) {
+	assert.expect( 2 );
 
 	$.widget( "ui.testWidget", {} );
-	equal( $.ui.testWidget.prototype.widgetEventPrefix, "testWidget" );
+	assert.equal( $.ui.testWidget.prototype.widgetEventPrefix, "testWidget" );
 
 	$.widget( "ui.testWidget", {} );
-	equal( $.ui.testWidget.prototype.widgetEventPrefix, "testWidget" );
+	assert.equal( $.ui.testWidget.prototype.widgetEventPrefix, "testWidget" );
 } );
 
-test( "inheritance", function() {
-	expect( 6 );
+QUnit.test( "inheritance", function( assert ) {
+	assert.expect( 6 );
 
 	// #5830 - Widget: Using inheritance overwrites the base classes options
 	$.widget( "ui.testWidgetBase", {
@@ -381,22 +382,22 @@ test( "inheritance", function() {
 		}
 	} );
 
-	equal( $.ui.testWidgetBase.prototype.widgetEventPrefix, "testWidgetBase",
+	assert.equal( $.ui.testWidgetBase.prototype.widgetEventPrefix, "testWidgetBase",
 		"base class event prefix" );
-	deepEqual( $.ui.testWidgetBase.prototype.options.obj, {
+	assert.deepEqual( $.ui.testWidgetBase.prototype.options.obj, {
 		key1: "foo",
 		key2: "bar"
 	}, "base class option object not overridden" );
-	deepEqual( $.ui.testWidgetBase.prototype.options.arr, [ "testing" ],
+	assert.deepEqual( $.ui.testWidgetBase.prototype.options.arr, [ "testing" ],
 		"base class option array not overridden" );
 
-	equal( $.ui.testWidgetExtension.prototype.widgetEventPrefix, "testWidgetExtension",
+	assert.equal( $.ui.testWidgetExtension.prototype.widgetEventPrefix, "testWidgetExtension",
 		"extension class event prefix" );
-	deepEqual( $.ui.testWidgetExtension.prototype.options.obj, {
+	assert.deepEqual( $.ui.testWidgetExtension.prototype.options.obj, {
 		key1: "baz",
 		key2: "bar"
 	}, "extension class option object extends base" );
-	deepEqual( $.ui.testWidgetExtension.prototype.options.arr, [ "alpha", "beta" ],
+	assert.deepEqual( $.ui.testWidgetExtension.prototype.options.arr, [ "alpha", "beta" ],
 		"extension class option array overwrites base" );
 
 	delete $.ui.testWidgetBase;
@@ -405,33 +406,33 @@ test( "inheritance", function() {
 	delete $.fn.testWidgetExtension;
 } );
 
-test( "._super()", function() {
-	expect( 9 );
+QUnit.test( "._super()", function( assert ) {
+	assert.expect( 9 );
 	var instance;
 	$.widget( "ui.testWidget", {
 		method: function( a, b ) {
-			deepEqual( this, instance, "this is correct in testWidget" );
-			deepEqual( a, 5, "parameter passed to testWidget" );
-			deepEqual( b, 20, "second parameter passed to testWidget" );
+			assert.deepEqual( this, instance, "this is correct in testWidget" );
+			assert.deepEqual( a, 5, "parameter passed to testWidget" );
+			assert.deepEqual( b, 20, "second parameter passed to testWidget" );
 			return a + b;
 		}
 	} );
 
 	$.widget( "ui.testWidget2", $.ui.testWidget, {
 		method: function( a, b ) {
-			deepEqual( this, instance, "this is correct in testWidget2" );
-			deepEqual( a, 5, "parameter passed to testWidget2" );
-			deepEqual( b, 10, "parameter passed to testWidget2" );
+			assert.deepEqual( this, instance, "this is correct in testWidget2" );
+			assert.deepEqual( a, 5, "parameter passed to testWidget2" );
+			assert.deepEqual( b, 10, "parameter passed to testWidget2" );
 			return this._super( a, b * 2 );
 		}
 	} );
 
 	$.widget( "ui.testWidget3", $.ui.testWidget2, {
 		method: function( a ) {
-			deepEqual( this, instance, "this is correct in testWidget3" );
-			deepEqual( a, 5, "parameter passed to testWidget3" );
+			assert.deepEqual( this, instance, "this is correct in testWidget3" );
+			assert.deepEqual( a, 5, "parameter passed to testWidget3" );
 			var ret = this._super( a, a * 2 );
-			deepEqual( ret, 25, "super returned value" );
+			assert.deepEqual( ret, 25, "super returned value" );
 		}
 	} );
 
@@ -443,34 +444,34 @@ test( "._super()", function() {
 	delete $.fn.testWidget2;
 } );
 
-test( "._superApply()", function() {
-	expect( 10 );
+QUnit.test( "._superApply()", function( assert ) {
+	assert.expect( 10 );
 	var instance;
 	$.widget( "ui.testWidget", {
 		method: function( a, b ) {
-			deepEqual( this, instance, "this is correct in testWidget" );
-			deepEqual( a, 5, "parameter passed to testWidget" );
-			deepEqual( b, 10, "second parameter passed to testWidget" );
+			assert.deepEqual( this, instance, "this is correct in testWidget" );
+			assert.deepEqual( a, 5, "parameter passed to testWidget" );
+			assert.deepEqual( b, 10, "second parameter passed to testWidget" );
 			return a + b;
 		}
 	} );
 
 	$.widget( "ui.testWidget2", $.ui.testWidget, {
 		method: function( a, b ) {
-			deepEqual( this, instance, "this is correct in testWidget2" );
-			deepEqual( a, 5, "parameter passed to testWidget2" );
-			deepEqual( b, 10, "second parameter passed to testWidget2" );
+			assert.deepEqual( this, instance, "this is correct in testWidget2" );
+			assert.deepEqual( a, 5, "parameter passed to testWidget2" );
+			assert.deepEqual( b, 10, "second parameter passed to testWidget2" );
 			return this._superApply( arguments );
 		}
 	} );
 
 	$.widget( "ui.testWidget3", $.ui.testWidget2, {
 		method: function( a, b ) {
-			deepEqual( this, instance, "this is correct in testWidget3" );
-			deepEqual( a, 5, "parameter passed to testWidget3" );
-			deepEqual( b, 10, "second parameter passed to testWidget3" );
+			assert.deepEqual( this, instance, "this is correct in testWidget3" );
+			assert.deepEqual( a, 5, "parameter passed to testWidget3" );
+			assert.deepEqual( b, 10, "second parameter passed to testWidget3" );
 			var ret = this._superApply( arguments );
-			deepEqual( ret, 15, "super returned value" );
+			assert.deepEqual( ret, 15, "super returned value" );
 		}
 	} );
 
@@ -482,22 +483,22 @@ test( "._superApply()", function() {
 	delete $.fn.testWidget2;
 } );
 
-test( "mixins", function() {
-	expect( 5 );
+QUnit.test( "mixins", function( assert ) {
+	assert.expect( 5 );
 
 	var mixin1 = {
 		foo: function() {
-			equal( method, "foo", "Methods from first mixin are copied over" );
+			assert.equal( method, "foo", "Methods from first mixin are copied over" );
 		}
 	};
 	var mixin2 = {
 		bar: function() {
-			equal( method, "bar", "Methods from second mixin are copied over" );
+			assert.equal( method, "bar", "Methods from second mixin are copied over" );
 		}
 	};
 	var prototype = {
 		baz: function() {
-			equal( method, "baz", "Methods from protoype are copied over" );
+			assert.equal( method, "baz", "Methods from protoype are copied over" );
 		}
 	};
 	var existingBar = mixin2.bar;
@@ -512,36 +513,36 @@ test( "mixins", function() {
 	$.ui.testWidget.prototype.baz();
 
 	mixin1.foo = function() {
-		ok( false, "Changes to a mixin don't change the prototype" );
+		assert.ok( false, "Changes to a mixin don't change the prototype" );
 	};
 	method = "foo";
 	$.ui.testWidget.prototype.foo();
 
 	$.ui.testWidget.prototype.bar = function() {};
-	strictEqual( mixin2.bar, existingBar, "Changes to a prototype don't change the mixin" );
+	assert.strictEqual( mixin2.bar, existingBar, "Changes to a prototype don't change the mixin" );
 } );
 
-test( "mixins with inheritance", function() {
-	expect( 4 );
+QUnit.test( "mixins with inheritance", function( assert ) {
+	assert.expect( 4 );
 
 	var mixin1 = {
 		foo: function() {
-			equal( method, "foo", "Methods from first mixin are copied over" );
+			assert.equal( method, "foo", "Methods from first mixin are copied over" );
 		}
 	};
 	var mixin2 = {
 		bar: function() {
-			equal( method, "bar", "Methods from second mixin are copied over" );
+			assert.equal( method, "bar", "Methods from second mixin are copied over" );
 		}
 	};
 	var parentPrototype = {
 		baz: function() {
-			equal( method, "baz", "Methods from parent protoype are copied over" );
+			assert.equal( method, "baz", "Methods from parent protoype are copied over" );
 		}
 	};
 	var childPrototype = {
 		qux: function() {
-			equal( method, "qux", "Methods from child protoype are copied over" );
+			assert.equal( method, "qux", "Methods from child protoype are copied over" );
 		}
 	};
 	var method;
@@ -561,8 +562,8 @@ test( "mixins with inheritance", function() {
 	delete $.fn.testWidget2;
 } );
 
-test( ".option() - getter", function() {
-	expect( 6 );
+QUnit.test( ".option() - getter", function( assert ) {
+	assert.expect( 6 );
 	$.widget( "ui.testWidget", {
 		_create: function() {}
 	} );
@@ -574,14 +575,14 @@ test( ".option() - getter", function() {
 			qux: [ "quux", "quuux" ]
 		} );
 
-	deepEqual( div.testWidget( "option", "x" ), null, "non-existent option" );
-	deepEqual( div.testWidget( "option", "foo" ), "bar", "single option - string" );
-	deepEqual( div.testWidget( "option", "baz" ), 5, "single option - number" );
-	deepEqual( div.testWidget( "option", "qux" ), [ "quux", "quuux" ],
+	assert.deepEqual( div.testWidget( "option", "x" ), null, "non-existent option" );
+	assert.deepEqual( div.testWidget( "option", "foo" ), "bar", "single option - string" );
+	assert.deepEqual( div.testWidget( "option", "baz" ), 5, "single option - number" );
+	assert.deepEqual( div.testWidget( "option", "qux" ), [ "quux", "quuux" ],
 		"single option - array" );
 
 	options = div.testWidget( "option" );
-	deepEqual( options, {
+	assert.deepEqual( options, {
 		baz: 5,
 		classes: {},
 		create: null,
@@ -590,12 +591,12 @@ test( ".option() - getter", function() {
 		qux: [ "quux", "quuux" ]
 	}, "full options hash returned" );
 	options.foo = "notbar";
-	deepEqual( div.testWidget( "option", "foo" ), "bar",
+	assert.deepEqual( div.testWidget( "option", "foo" ), "bar",
 		"modifying returned options hash does not modify plugin instance" );
 } );
 
-test( ".option() - deep option getter", function() {
-	expect( 5 );
+QUnit.test( ".option() - deep option getter", function( assert ) {
+	assert.expect( 5 );
 	$.widget( "ui.testWidget", {} );
 	var div = $( "<div>" ).testWidget( {
 		foo: {
@@ -605,16 +606,16 @@ test( ".option() - deep option getter", function() {
 			}
 		}
 	} );
-	equal( div.testWidget( "option", "foo.bar" ), "baz", "one level deep - string" );
-	deepEqual( div.testWidget( "option", "foo.qux" ), { quux: "xyzzy" },
+	assert.equal( div.testWidget( "option", "foo.bar" ), "baz", "one level deep - string" );
+	assert.deepEqual( div.testWidget( "option", "foo.qux" ), { quux: "xyzzy" },
 		"one level deep - object" );
-	equal( div.testWidget( "option", "foo.qux.quux" ), "xyzzy", "two levels deep - string" );
-	equal( div.testWidget( "option", "x.y" ), null, "top level non-existent" );
-	equal( div.testWidget( "option", "foo.x.y" ), null, "one level deep - non-existent" );
+	assert.equal( div.testWidget( "option", "foo.qux.quux" ), "xyzzy", "two levels deep - string" );
+	assert.equal( div.testWidget( "option", "x.y" ), null, "top level non-existent" );
+	assert.equal( div.testWidget( "option", "foo.x.y" ), null, "one level deep - non-existent" );
 } );
 
-test( ".option() - delegate to ._setOptions()", function() {
-	expect( 2 );
+QUnit.test( ".option() - delegate to ._setOptions()", function( assert ) {
+	assert.expect( 2 );
 	var div,
 		calls = [];
 	$.widget( "ui.testWidget", {
@@ -627,19 +628,19 @@ test( ".option() - delegate to ._setOptions()", function() {
 
 	calls = [];
 	div.testWidget( "option", "foo", "bar" );
-	deepEqual( calls, [ { foo: "bar" } ], "_setOptions called for single option" );
+	assert.deepEqual( calls, [ { foo: "bar" } ], "_setOptions called for single option" );
 
 	calls = [];
 	div.testWidget( "option", {
 		bar: "qux",
 		quux: "quuux"
 	} );
-	deepEqual( calls, [ { bar: "qux", quux: "quuux" } ],
+	assert.deepEqual( calls, [ { bar: "qux", quux: "quuux" } ],
 		"_setOptions called with multiple options" );
 } );
 
-test( ".option() - delegate to ._setOption()", function() {
-	expect( 3 );
+QUnit.test( ".option() - delegate to ._setOption()", function( assert ) {
+	assert.expect( 3 );
 	var div,
 		calls = [];
 	$.widget( "ui.testWidget", {
@@ -655,12 +656,12 @@ test( ".option() - delegate to ._setOption()", function() {
 
 	calls = [];
 	div.testWidget( "option", "foo", "bar" );
-	deepEqual( calls, [ { key: "foo", val: "bar" } ],
+	assert.deepEqual( calls, [ { key: "foo", val: "bar" } ],
 		"_setOption called for single option" );
 
 	calls = [];
 	div.testWidget( "option", "foo", undefined );
-	deepEqual( calls, [ { key: "foo", val: undefined } ],
+	assert.deepEqual( calls, [ { key: "foo", val: undefined } ],
 		"_setOption called for single option where value is undefined" );
 
 	calls = [];
@@ -668,21 +669,21 @@ test( ".option() - delegate to ._setOption()", function() {
 		bar: "qux",
 		quux: "quuux"
 	} );
-	deepEqual( calls, [
+	assert.deepEqual( calls, [
 		{ key: "bar", val: "qux" },
 		{ key: "quux", val: "quuux" }
 	], "_setOption called with multiple options" );
 } );
 
-test( ".option() - deep option setter", function() {
-	expect( 9 );
+QUnit.test( ".option() - deep option setter", function( assert ) {
+	assert.expect( 9 );
 	$.widget( "ui.testWidget", {} );
 	var result, div = $( "<div>" ).testWidget();
 	function deepOption( from, to, msg ) {
 		div.testWidget( "instance" ).options.foo = from;
 		$.ui.testWidget.prototype._setOption = function( key, value ) {
-			deepEqual( key, "foo", msg + ": key" );
-			deepEqual( value, to, msg + ": value" );
+			assert.deepEqual( key, "foo", msg + ": key" );
+			assert.deepEqual( value, to, msg + ": value" );
 		};
 	}
 
@@ -693,7 +694,7 @@ test( ".option() - deep option setter", function() {
 
 	result = div.testWidget( "option", "foo.bar", undefined );
 
-	deepEqual ( result, div, "option should return widget on successful set operation" );
+	assert.deepEqual( result, div, "option should return widget on successful set operation" );
 
 	deepOption( null, { bar: "baz" }, "null" );
 	div.testWidget( "option", "foo.bar", "baz" );
@@ -705,32 +706,32 @@ test( ".option() - deep option setter", function() {
 	div.testWidget( "option", "foo.qux.newOpt", "newVal" );
 } );
 
-test( ".enable()", function() {
-	expect( 2 );
+QUnit.test( ".enable()", function( assert ) {
+	assert.expect( 2 );
 	$.widget( "ui.testWidget", {
 		_create: function() {},
 		_setOption: function( key, val ) {
-			deepEqual( key, "disabled", "_setOption called with disabled option" );
-			deepEqual( val, false, "disabled set to false" );
+			assert.deepEqual( key, "disabled", "_setOption called with disabled option" );
+			assert.deepEqual( val, false, "disabled set to false" );
 		}
 	} );
 	$( "<div>" ).testWidget().testWidget( "enable" );
 } );
 
-test( ".disable()", function() {
-	expect( 2 );
+QUnit.test( ".disable()", function( assert ) {
+	assert.expect( 2 );
 	$.widget( "ui.testWidget", {
 		_create: function() {},
 		_setOption: function( key, val ) {
-			deepEqual( key, "disabled", "_setOption called with disabled option" );
-			deepEqual( val, true, "disabled set to true" );
+			assert.deepEqual( key, "disabled", "_setOption called with disabled option" );
+			assert.deepEqual( val, true, "disabled set to true" );
 		}
 	} );
 	$( "<div>" ).testWidget().testWidget( "disable" );
 } );
 
-test( "._setOptionDisabled()", function() {
-	expect( 3 );
+QUnit.test( "._setOptionDisabled()", function( assert ) {
+	assert.expect( 3 );
 
 	var method;
 	var widget;
@@ -742,38 +743,38 @@ test( "._setOptionDisabled()", function() {
 	} );
 
 	method = function() {
-		ok( false, "._setOptionDisabled() called on init when not disabled" );
+		assert.ok( false, "._setOptionDisabled() called on init when not disabled" );
 	};
 	$( "<div>" ).testWidget();
 
 	method = function( value ) {
-		strictEqual( value, true, "._setOptionDisabled called on init when disabled" );
+		assert.strictEqual( value, true, "._setOptionDisabled called on init when disabled" );
 	};
 	widget = $( "<div>" ).testWidget( { disabled: true } );
 
 	method = function( value ) {
-		strictEqual( value, false, "._setOptionDisabled called when enabling" );
+		assert.strictEqual( value, false, "._setOptionDisabled called when enabling" );
 	};
 	widget.testWidget( "enable" );
 
 	method = function( value ) {
-		strictEqual( value, true, "._setOptionDisabled called when disabling" );
+		assert.strictEqual( value, true, "._setOptionDisabled called when disabling" );
 	};
 	widget.testWidget( "option", "disabled", true );
 } );
 
-test( ".widget() - base", function() {
-	expect( 2 );
+QUnit.test( ".widget() - base", function( assert ) {
+	assert.expect( 2 );
 	var constructor = $.widget( "ui.testWidget", {
 			_create: function() {}
 		} ),
 		div = $( "<div>" ).testWidget();
-	deepEqual( div[ 0 ], div.testWidget( "widget" )[ 0 ] );
-	deepEqual( constructor, $.ui.testWidget, "$.widget returns the constructor" );
+	assert.deepEqual( div[ 0 ], div.testWidget( "widget" )[ 0 ] );
+	assert.deepEqual( constructor, $.ui.testWidget, "$.widget returns the constructor" );
 } );
 
-test( ".widget() - overriden", function() {
-	expect( 1 );
+QUnit.test( ".widget() - overriden", function( assert ) {
+	assert.expect( 1 );
 	var wrapper = $( "<div>" );
 	$.widget( "ui.testWidget", {
 		_create: function() {},
@@ -781,11 +782,11 @@ test( ".widget() - overriden", function() {
 			return wrapper;
 		}
 	} );
-	deepEqual( wrapper[ 0 ], $( "<div>" ).testWidget().testWidget( "widget" )[ 0 ] );
+	assert.deepEqual( wrapper[ 0 ], $( "<div>" ).testWidget().testWidget( "widget" )[ 0 ] );
 } );
 
-test( ".instance()", function() {
-	expect( 2 );
+QUnit.test( ".instance()", function( assert ) {
+	assert.expect( 2 );
 	var div;
 
 	$.widget( "ui.testWidget", {
@@ -793,13 +794,13 @@ test( ".instance()", function() {
 	} );
 
 	div = $( "<div>" );
-	equal( div.testWidget( "instance" ), undefined );
+	assert.equal( div.testWidget( "instance" ), undefined );
 	div.testWidget();
-	equal( div.testWidget( "instance" ), div.testWidget( "instance" ) );
+	assert.equal( div.testWidget( "instance" ), div.testWidget( "instance" ) );
 } );
 
-test( "._on() to element (default)", function() {
-	expect( 12 );
+QUnit.test( "._on() to element (default)", function( assert ) {
+	assert.expect( 12 );
 	var that, widget;
 	$.widget( "ui.testWidget", {
 		_create: function() {
@@ -810,14 +811,14 @@ test( "._on() to element (default)", function() {
 			} );
 		},
 		keyup: function( event ) {
-			equal( that, this );
-			equal( that.element[ 0 ], event.currentTarget );
-			equal( "keyup", event.type );
+			assert.equal( that, this );
+			assert.equal( that.element[ 0 ], event.currentTarget );
+			assert.equal( "keyup", event.type );
 		},
 		keydown: function( event ) {
-			equal( that, this );
-			equal( that.element[ 0 ], event.currentTarget );
-			equal( "keydown", event.type );
+			assert.equal( that, this );
+			assert.equal( that.element[ 0 ], event.currentTarget );
+			assert.equal( "keydown", event.type );
 		}
 	} );
 	widget = $( "<div></div>" )
@@ -838,8 +839,8 @@ test( "._on() to element (default)", function() {
 		.trigger( "keydown" );
 } );
 
-test( "._on() to element with suppressDisabledCheck", function() {
-	expect( 18 );
+QUnit.test( "._on() to element with suppressDisabledCheck", function( assert ) {
+	assert.expect( 18 );
 	var that, widget;
 	$.widget( "ui.testWidget", {
 		_create: function() {
@@ -850,14 +851,14 @@ test( "._on() to element with suppressDisabledCheck", function() {
 			} );
 		},
 		keyup: function( event ) {
-			equal( that, this );
-			equal( that.element[ 0 ], event.currentTarget );
-			equal( "keyup", event.type );
+			assert.equal( that, this );
+			assert.equal( that.element[ 0 ], event.currentTarget );
+			assert.equal( "keyup", event.type );
 		},
 		keydown: function( event ) {
-			equal( that, this );
-			equal( that.element[ 0 ], event.currentTarget );
-			equal( "keydown", event.type );
+			assert.equal( that, this );
+			assert.equal( that.element[ 0 ], event.currentTarget );
+			assert.equal( "keydown", event.type );
 		}
 	} );
 	widget = $( "<div></div>" )
@@ -878,8 +879,8 @@ test( "._on() to element with suppressDisabledCheck", function() {
 		.trigger( "keydown" );
 } );
 
-test( "._on() to descendent", function() {
-	expect( 12 );
+QUnit.test( "._on() to descendent", function( assert ) {
+	assert.expect( 12 );
 	var that, widget, descendant;
 	$.widget( "ui.testWidget", {
 		_create: function() {
@@ -890,18 +891,18 @@ test( "._on() to descendent", function() {
 			} );
 		},
 		keyup: function( event ) {
-			equal( that, this );
-			equal( that.element.find( "strong" )[ 0 ], event.currentTarget );
-			equal( "keyup", event.type );
+			assert.equal( that, this );
+			assert.equal( that.element.find( "strong" )[ 0 ], event.currentTarget );
+			assert.equal( "keyup", event.type );
 		},
 		keydown: function( event ) {
-			equal( that, this );
-			equal( that.element.find( "strong" )[ 0 ], event.currentTarget );
-			equal( "keydown", event.type );
+			assert.equal( that, this );
+			assert.equal( that.element.find( "strong" )[ 0 ], event.currentTarget );
+			assert.equal( "keydown", event.type );
 		}
 	} );
 
-	// trigger events on both widget and descendent to ensure that only descendent receives them
+	// Trigger events on both widget and descendent to ensure that only descendent receives them
 	widget = $( "<div><p><strong>hello</strong> world</p></div>" )
 		.testWidget()
 		.trigger( "keyup" )
@@ -936,24 +937,24 @@ test( "._on() to descendent", function() {
 		.trigger( "keydown" );
 } );
 
-test( "_on() with delegate", function() {
-	expect( 8 );
+QUnit.test( "_on() with delegate", function( assert ) {
+	assert.expect( 8 );
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			var uuid = this.uuid;
 			this.element = {
 				on: function( event, handler ) {
-					equal( event, "click.testWidget" + uuid );
-					ok( $.isFunction( handler ) );
+					assert.equal( event, "click.testWidget" + uuid );
+					assert.ok( $.isFunction( handler ) );
 				},
 				trigger: $.noop
 			};
 			this.widget = function() {
 				return {
 					on: function( event, selector, handler ) {
-						equal( selector, "a" );
-						equal( event, "click.testWidget" + uuid );
-						ok( $.isFunction( handler ) );
+						assert.equal( selector, "a" );
+						assert.equal( event, "click.testWidget" + uuid );
+						assert.ok( $.isFunction( handler ) );
 					}
 				};
 			};
@@ -964,9 +965,9 @@ test( "_on() with delegate", function() {
 			this.widget = function() {
 				return {
 					on: function( event, selector, handler ) {
-						equal( selector, "form fieldset > input" );
-						equal( event, "change.testWidget" + uuid );
-						ok( $.isFunction( handler ) );
+						assert.equal( selector, "form fieldset > input" );
+						assert.equal( event, "change.testWidget" + uuid );
+						assert.ok( $.isFunction( handler ) );
 					}
 				};
 			};
@@ -978,8 +979,8 @@ test( "_on() with delegate", function() {
 	$.ui.testWidget();
 } );
 
-test( "_on() with delegate to descendent", function() {
-	expect( 4 );
+QUnit.test( "_on() with delegate to descendent", function( assert ) {
+	assert.expect( 4 );
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			this.target = $( "<p><strong>hello</strong> world</p>" );
@@ -991,19 +992,19 @@ test( "_on() with delegate to descendent", function() {
 			this.child.trigger( "keyup" );
 		},
 		handlerDirect: function( event ) {
-			deepEqual( event.currentTarget, this.target[ 0 ] );
-			deepEqual( event.target, this.child[ 0 ] );
+			assert.deepEqual( event.currentTarget, this.target[ 0 ] );
+			assert.deepEqual( event.target, this.child[ 0 ] );
 		},
 		handlerDelegated: function( event ) {
-			deepEqual( event.currentTarget, this.child[ 0 ] );
-			deepEqual( event.target, this.child[ 0 ] );
+			assert.deepEqual( event.currentTarget, this.child[ 0 ] );
+			assert.deepEqual( event.target, this.child[ 0 ] );
 		}
 	} );
 	$.ui.testWidget();
 } );
 
-test( "_on() to common element", function() {
-	expect( 4 );
+QUnit.test( "_on() to common element", function( assert ) {
+	assert.expect( 4 );
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			this._on( this.document, {
@@ -1014,16 +1015,16 @@ test( "_on() to common element", function() {
 			} );
 		},
 		_handler: function() {
-			ok( true, "handler triggered" );
+			assert.ok( true, "handler triggered" );
 		},
 		_colonHandler: function() {
-			ok( true, "colon handler triggered" );
+			assert.ok( true, "colon handler triggered" );
 		},
 		_dashHandler: function() {
-			ok( true, "dash handler triggered" );
+			assert.ok( true, "dash handler triggered" );
 		},
 		_commbinedHandler: function() {
-			ok( true, "combined handler triggered" );
+			assert.ok( true, "combined handler triggered" );
 		}
 	} );
 	var widget = $( "#widget" ).testWidget().testWidget( "instance" );
@@ -1035,18 +1036,18 @@ test( "_on() to common element", function() {
 	$( document ).trigger( "with-dashes:and-colons" );
 } );
 
-test( "_off() - single event", function() {
-	expect( 3 );
+QUnit.test( "_off() - single event", function( assert ) {
+	assert.expect( 3 );
 
 	$.widget( "ui.testWidget", {} );
 	var shouldTriggerWidget, shouldTriggerOther,
 		element = $( "#widget" ),
 		widget = element.testWidget().testWidget( "instance" );
 	widget._on( element, { foo: function() {
-		ok( shouldTriggerWidget, "foo called from _on" );
+		assert.ok( shouldTriggerWidget, "foo called from _on" );
 	} } );
 	element.on( "foo", function() {
-		ok( shouldTriggerOther, "foo called from bind" );
+		assert.ok( shouldTriggerOther, "foo called from bind" );
 	} );
 	shouldTriggerWidget = true;
 	shouldTriggerOther = true;
@@ -1056,8 +1057,8 @@ test( "_off() - single event", function() {
 	element.trigger( "foo" );
 } );
 
-test( "_off() - multiple events", function() {
-	expect( 6 );
+QUnit.test( "_off() - multiple events", function( assert ) {
+	assert.expect( 6 );
 
 	$.widget( "ui.testWidget", {} );
 	var shouldTriggerWidget, shouldTriggerOther,
@@ -1065,14 +1066,14 @@ test( "_off() - multiple events", function() {
 		widget = element.testWidget().testWidget( "instance" );
 	widget._on( element, {
 		foo: function() {
-			ok( shouldTriggerWidget, "foo called from _on" );
+			assert.ok( shouldTriggerWidget, "foo called from _on" );
 		},
 		bar: function() {
-			ok( shouldTriggerWidget, "bar called from _on" );
+			assert.ok( shouldTriggerWidget, "bar called from _on" );
 		}
 	} );
 	element.on( "foo bar", function( event ) {
-		ok( shouldTriggerOther, event.type + " called from bind" );
+		assert.ok( shouldTriggerOther, event.type + " called from bind" );
 	} );
 	shouldTriggerWidget = true;
 	shouldTriggerOther = true;
@@ -1084,8 +1085,8 @@ test( "_off() - multiple events", function() {
 	element.trigger( "bar" );
 } );
 
-test( "_off() - all events", function() {
-	expect( 6 );
+QUnit.test( "_off() - all events", function( assert ) {
+	assert.expect( 6 );
 
 	$.widget( "ui.testWidget", {} );
 	var shouldTriggerWidget, shouldTriggerOther,
@@ -1093,14 +1094,14 @@ test( "_off() - all events", function() {
 		widget = element.testWidget().testWidget( "instance" );
 	widget._on( element, {
 		foo: function() {
-			ok( shouldTriggerWidget, "foo called from _on" );
+			assert.ok( shouldTriggerWidget, "foo called from _on" );
 		},
 		bar: function() {
-			ok( shouldTriggerWidget, "bar called from _on" );
+			assert.ok( shouldTriggerWidget, "bar called from _on" );
 		}
 	} );
 	element.on( "foo bar", function( event ) {
-		ok( shouldTriggerOther, event.type + " called from bind" );
+		assert.ok( shouldTriggerOther, event.type + " called from bind" );
 	} );
 	shouldTriggerWidget = true;
 	shouldTriggerOther = true;
@@ -1112,8 +1113,8 @@ test( "_off() - all events", function() {
 	element.trigger( "bar" );
 } );
 
-test( "._hoverable()", function( assert ) {
-	expect( 10 );
+QUnit.test( "._hoverable()", function( assert ) {
+	assert.expect( 10 );
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			this._hoverable( this.element.children() );
@@ -1144,8 +1145,8 @@ test( "._hoverable()", function( assert ) {
 	assert.lacksClasses( div, "ui-state-hover", "event handler removed on destroy" );
 } );
 
-test( "._focusable()", function( assert ) {
-	expect( 10 );
+QUnit.test( "._focusable()", function( assert ) {
+	assert.expect( 10 );
 	$.widget( "ui.testWidget", {
 		_create: function() {
 			this._focusable( this.element.children() );
@@ -1176,8 +1177,8 @@ test( "._focusable()", function( assert ) {
 	assert.lacksClasses( div, "ui-state-focus", "event handler removed on destroy" );
 } );
 
-test( "._trigger() - no event, no ui", function() {
-	expect( 7 );
+QUnit.test( "._trigger() - no event, no ui", function( assert ) {
+	assert.expect( 7 );
 	var handlers = [];
 
 	$.widget( "ui.testWidget", {
@@ -1186,19 +1187,19 @@ test( "._trigger() - no event, no ui", function() {
 
 	$( "#widget" ).testWidget( {
 		foo: function( event, ui ) {
-			deepEqual( event.type, "testwidgetfoo", "correct event type in callback" );
-			deepEqual( ui, {}, "empty ui hash passed" );
+			assert.deepEqual( event.type, "testwidgetfoo", "correct event type in callback" );
+			assert.deepEqual( ui, {}, "empty ui hash passed" );
 			handlers.push( "callback" );
 		}
 	} );
 	$( document ).add( "#widget-wrapper" ).add( "#widget" )
 		.on( "testwidgetfoo", function( event, ui ) {
-			deepEqual( ui, {}, "empty ui hash passed" );
+			assert.deepEqual( ui, {}, "empty ui hash passed" );
 			handlers.push( this );
 		} );
-	deepEqual( $( "#widget" ).testWidget( "instance" )._trigger( "foo" ), true,
+	assert.deepEqual( $( "#widget" ).testWidget( "instance" )._trigger( "foo" ), true,
 		"_trigger returns true when event is not cancelled" );
-	deepEqual( handlers, [
+	assert.deepEqual( handlers, [
 		$( "#widget" )[ 0 ],
 		$( "#widget-wrapper" )[ 0 ],
 		document,
@@ -1208,8 +1209,8 @@ test( "._trigger() - no event, no ui", function() {
 	$( document ).off( "testwidgetfoo" );
 } );
 
-test( "._trigger() - cancelled event", function() {
-	expect( 3 );
+QUnit.test( "._trigger() - cancelled event", function( assert ) {
+	assert.expect( 3 );
 
 	$.widget( "ui.testWidget", {
 		_create: function() {}
@@ -1217,19 +1218,19 @@ test( "._trigger() - cancelled event", function() {
 
 	$( "#widget" ).testWidget( {
 		foo: function() {
-			ok( true, "callback invoked even if event is cancelled" );
+			assert.ok( true, "callback invoked even if event is cancelled" );
 		}
 	} )
 	.on( "testwidgetfoo", function() {
-		ok( true, "event was triggered" );
+		assert.ok( true, "event was triggered" );
 		return false;
 	} );
-	deepEqual( $( "#widget" ).testWidget( "instance" )._trigger( "foo" ), false,
+	assert.deepEqual( $( "#widget" ).testWidget( "instance" )._trigger( "foo" ), false,
 		"_trigger returns false when event is cancelled" );
 } );
 
-test( "._trigger() - cancelled callback", function() {
-	expect( 1 );
+QUnit.test( "._trigger() - cancelled callback", function( assert ) {
+	assert.expect( 1 );
 	$.widget( "ui.testWidget", {
 		_create: function() {}
 	} );
@@ -1239,12 +1240,12 @@ test( "._trigger() - cancelled callback", function() {
 			return false;
 		}
 	} );
-	deepEqual( $( "#widget" ).testWidget( "instance" )._trigger( "foo" ), false,
+	assert.deepEqual( $( "#widget" ).testWidget( "instance" )._trigger( "foo" ), false,
 		"_trigger returns false when callback returns false" );
 } );
 
-test( "._trigger() - provide event and ui", function() {
-	expect( 7 );
+QUnit.test( "._trigger() - provide event and ui", function( assert ) {
+	assert.expect( 7 );
 
 	var originalEvent = $.Event( "originalTest" );
 	$.widget( "ui.testWidget", {
@@ -1258,7 +1259,7 @@ test( "._trigger() - provide event and ui", function() {
 					}
 				};
 			this._trigger( "foo", originalEvent, ui );
-			deepEqual( ui, {
+			assert.deepEqual( ui, {
 				foo: "notbar",
 				baz: {
 					qux: 10,
@@ -1268,8 +1269,8 @@ test( "._trigger() - provide event and ui", function() {
 		}
 	} );
 	$( "#widget" ).on( "testwidgetfoo", function( event, ui ) {
-		equal( event.originalEvent, originalEvent, "original event object passed" );
-		deepEqual( ui, {
+		assert.equal( event.originalEvent, originalEvent, "original event object passed" );
+		assert.deepEqual( ui, {
 			foo: "bar",
 			baz: {
 				qux: 5,
@@ -1279,8 +1280,8 @@ test( "._trigger() - provide event and ui", function() {
 		ui.foo = "notbar";
 	} );
 	$( "#widget-wrapper" ).on( "testwidgetfoo", function( event, ui ) {
-		equal( event.originalEvent, originalEvent, "original event object passed" );
-		deepEqual( ui, {
+		assert.equal( event.originalEvent, originalEvent, "original event object passed" );
+		assert.deepEqual( ui, {
 			foo: "notbar",
 			baz: {
 				qux: 5,
@@ -1291,8 +1292,8 @@ test( "._trigger() - provide event and ui", function() {
 	} );
 	$( "#widget" ).testWidget( {
 		foo: function( event, ui ) {
-			equal( event.originalEvent, originalEvent, "original event object passed" );
-			deepEqual( ui, {
+			assert.equal( event.originalEvent, originalEvent, "original event object passed" );
+			assert.deepEqual( ui, {
 				foo: "notbar",
 				baz: {
 					qux: 10,
@@ -1305,10 +1306,10 @@ test( "._trigger() - provide event and ui", function() {
 	.testWidget( "testEvent" );
 } );
 
-test( "._trigger() - array as ui", function() {
+QUnit.test( "._trigger() - array as ui", function( assert ) {
 
 	// #6795 - Widget: handle array arguments to _trigger consistently
-	expect( 4 );
+	assert.expect( 4 );
 
 	$.widget( "ui.testWidget", {
 		_create: function() {},
@@ -1327,27 +1328,27 @@ test( "._trigger() - array as ui", function() {
 		}
 	} );
 	$( "#widget" ).on( "testwidgetfoo", function( event, ui, extra ) {
-		deepEqual( ui, {
+		assert.deepEqual( ui, {
 			foo: "bar",
 			baz: {
 				qux: 5,
 				quux: 20
 			}
 		}, "event: ui hash passed" );
-		deepEqual( extra, {
+		assert.deepEqual( extra, {
 			bar: 5
 		}, "event: extra argument passed" );
 	} );
 	$( "#widget" ).testWidget( {
 		foo: function( event, ui, extra ) {
-			deepEqual( ui, {
+			assert.deepEqual( ui, {
 				foo: "bar",
 				baz: {
 					qux: 5,
 					quux: 20
 				}
 			}, "callback: ui hash passed" );
-			deepEqual( extra, {
+			assert.deepEqual( extra, {
 				bar: 5
 			}, "callback: extra argument passed" );
 		}
@@ -1355,8 +1356,8 @@ test( "._trigger() - array as ui", function() {
 	.testWidget( "testEvent" );
 } );
 
-test( "._trigger() - instance as element", function() {
-	expect( 4 );
+QUnit.test( "._trigger() - instance as element", function( assert ) {
+	assert.expect( 4 );
 	$.widget( "ui.testWidget", {
 		defaultElement: null,
 		testEvent: function() {
@@ -1365,20 +1366,20 @@ test( "._trigger() - instance as element", function() {
 	} );
 	var instance = $.ui.testWidget( {
 		foo: function( event, ui ) {
-			equal( event.type, "testwidgetfoo", "event object passed to callback" );
-			deepEqual( ui, { foo: "bar" }, "ui object passed to callback" );
+			assert.equal( event.type, "testwidgetfoo", "event object passed to callback" );
+			assert.deepEqual( ui, { foo: "bar" }, "ui object passed to callback" );
 		}
 	} );
 	$( instance ).on( "testwidgetfoo", function( event, ui ) {
-		equal( event.type, "testwidgetfoo", "event object passed to event handler" );
-		deepEqual( ui, { foo: "bar" }, "ui object passed to event handler" );
+		assert.equal( event.type, "testwidgetfoo", "event object passed to event handler" );
+		assert.deepEqual( ui, { foo: "bar" }, "ui object passed to event handler" );
 	} );
 	instance.testEvent();
 } );
 
 ( function() {
-	function shouldDestroy( expected, callback ) {
-		expect( 1 );
+	function shouldDestroy( assert, expected, callback ) {
+		assert.expect( 1 );
 		var destroyed = false;
 		$.widget( "ui.testWidget", {
 			_create: function() {},
@@ -1387,114 +1388,114 @@ test( "._trigger() - instance as element", function() {
 			}
 		} );
 		callback();
-		equal( destroyed, expected );
+		assert.equal( destroyed, expected );
 	}
 
-	test( "auto-destroy - .remove()", function() {
-		shouldDestroy( true, function() {
+	QUnit.test( "auto-destroy - .remove()", function( assert ) {
+		shouldDestroy( assert, true, function() {
 			$( "#widget" ).testWidget().remove();
 		} );
 	} );
 
-	test( "auto-destroy - .remove() when disabled", function() {
-		shouldDestroy( true, function() {
+	QUnit.test( "auto-destroy - .remove() when disabled", function( assert ) {
+		shouldDestroy( assert, true, function() {
 			$( "#widget" ).testWidget( { disabled: true } ).remove();
 		} );
 	} );
 
-	test( "auto-destroy - .remove() on parent", function() {
-		shouldDestroy( true, function() {
+	QUnit.test( "auto-destroy - .remove() on parent", function( assert ) {
+		shouldDestroy( assert, true, function() {
 			$( "#widget" ).testWidget().parent().remove();
 		} );
 	} );
 
-	test( "auto-destroy - .remove() on child", function() {
-		shouldDestroy( false, function() {
+	QUnit.test( "auto-destroy - .remove() on child", function( assert ) {
+		shouldDestroy( assert, false, function() {
 			$( "#widget" ).testWidget().children().remove();
 		} );
 	} );
 
-	test( "auto-destroy - .empty()", function() {
-		shouldDestroy( false, function() {
+	QUnit.test( "auto-destroy - .empty()", function( assert ) {
+		shouldDestroy( assert, false, function() {
 			$( "#widget" ).testWidget().empty();
 		} );
 	} );
 
-	test( "auto-destroy - .empty() on parent", function() {
-		shouldDestroy( true, function() {
+	QUnit.test( "auto-destroy - .empty() on parent", function( assert ) {
+		shouldDestroy( assert, true, function() {
 			$( "#widget" ).testWidget().parent().empty();
 		} );
 	} );
 
-	test( "auto-destroy - .detach()", function() {
-		shouldDestroy( false, function() {
+	QUnit.test( "auto-destroy - .detach()", function( assert ) {
+		shouldDestroy( assert, false, function() {
 			$( "#widget" ).testWidget().detach();
 		} );
 	} );
 
-	test( "destroy - remove event bubbling", function() {
-		shouldDestroy( false, function() {
+	QUnit.test( "destroy - remove event bubbling", function( assert ) {
+		shouldDestroy( assert, false, function() {
 			$( "<div>child</div>" ).appendTo( $( "#widget" ).testWidget() )
 				.trigger( "remove" );
 		} );
 	} );
 }() );
 
-test( "redefine", function() {
-	expect( 4 );
+QUnit.test( "redefine", function( assert ) {
+	assert.expect( 4 );
 	$.widget( "ui.testWidget", {
 		method: function( str ) {
-			strictEqual( this, instance, "original invoked with correct this" );
-			equal( str, "bar", "original invoked with correct parameter" );
+			assert.strictEqual( this, instance, "original invoked with correct this" );
+			assert.equal( str, "bar", "original invoked with correct parameter" );
 		}
 	} );
 	$.ui.testWidget.foo = "bar";
 	$.widget( "ui.testWidget", $.ui.testWidget, {
 		method: function( str ) {
-			equal( str, "foo", "new invoked with correct parameter" );
+			assert.equal( str, "foo", "new invoked with correct parameter" );
 			this._super( "bar" );
 		}
 	} );
 
 	var instance = new $.ui.testWidget( {} );
 	instance.method( "foo" );
-	equal( $.ui.testWidget.foo, "bar", "static properties remain" );
+	assert.equal( $.ui.testWidget.foo, "bar", "static properties remain" );
 } );
 
-test( "redefine deep prototype chain", function() {
-	expect( 8 );
+QUnit.test( "redefine deep prototype chain", function( assert ) {
+	assert.expect( 8 );
 	$.widget( "ui.testWidget", {
 		method: function( str ) {
-			strictEqual( this, instance, "original invoked with correct this" );
-			equal( str, "level 4", "original invoked with correct parameter" );
+			assert.strictEqual( this, instance, "original invoked with correct this" );
+			assert.equal( str, "level 4", "original invoked with correct parameter" );
 		}
 	} );
 	$.widget( "ui.testWidget2", $.ui.testWidget, {
 		method: function( str ) {
-			strictEqual( this, instance, "testWidget2 invoked with correct this" );
-			equal( str, "level 2", "testWidget2 invoked with correct parameter" );
+			assert.strictEqual( this, instance, "testWidget2 invoked with correct this" );
+			assert.equal( str, "level 2", "testWidget2 invoked with correct parameter" );
 			this._super( "level 3" );
 		}
 	} );
 	$.widget( "ui.testWidget3", $.ui.testWidget2, {
 		method: function( str ) {
-			strictEqual( this, instance, "testWidget3 invoked with correct this" );
-			equal( str, "level 1", "testWidget3 invoked with correct parameter" );
+			assert.strictEqual( this, instance, "testWidget3 invoked with correct this" );
+			assert.equal( str, "level 1", "testWidget3 invoked with correct parameter" );
 			this._super( "level 2" );
 		}
 	} );
 
-	// redefine testWidget after other widgets have inherited from it
+	// Redefine testWidget after other widgets have inherited from it
 	// this tests whether the inheriting widgets get updated prototype chains
 	$.widget( "ui.testWidget", $.ui.testWidget, {
 		method: function( str ) {
-			strictEqual( this, instance, "new invoked with correct this" );
-			equal( str, "level 3", "new invoked with correct parameter" );
+			assert.strictEqual( this, instance, "new invoked with correct this" );
+			assert.equal( str, "level 3", "new invoked with correct parameter" );
 			this._super( "level 4" );
 		}
 	} );
 
-	// redefine testWidget3 after it has been automatically redefined
+	// Redefine testWidget3 after it has been automatically redefined
 	// this tests whether we properly handle _super() when the topmost prototype
 	// doesn't have the method defined
 	$.widget( "ui.testWidget3", $.ui.testWidget3, {} );
@@ -1508,23 +1509,23 @@ test( "redefine deep prototype chain", function() {
 	delete $.fn.testWidget2;
 } );
 
-test( "redefine - widgetEventPrefix", function() {
-	expect( 2 );
+QUnit.test( "redefine - widgetEventPrefix", function( assert ) {
+	assert.expect( 2 );
 
 	$.widget( "ui.testWidget", {
 		widgetEventPrefix: "test"
 	} );
-	equal( $.ui.testWidget.prototype.widgetEventPrefix, "test",
+	assert.equal( $.ui.testWidget.prototype.widgetEventPrefix, "test",
 		"cusotm prefix in original" );
 
 	$.widget( "ui.testWidget", $.ui.testWidget, {} );
-	equal( $.ui.testWidget.prototype.widgetEventPrefix, "test",
+	assert.equal( $.ui.testWidget.prototype.widgetEventPrefix, "test",
 		"cusotm prefix in extension" );
 
 } );
 
-test( "mixins", function() {
-	expect( 2 );
+QUnit.test( "mixins", function( assert ) {
+	assert.expect( 2 );
 
 	var mixin = {
 		method: function() {
@@ -1545,14 +1546,15 @@ test( "mixins", function() {
 	$.widget( "ui.testWidget1", $.ui.testWidget1, mixin );
 	$.widget( "ui.testWidget2", $.ui.testWidget2, mixin );
 
-	equal( $( "<div>" ).testWidget1().testWidget1( "method" ),
+	assert.equal( $( "<div>" ).testWidget1().testWidget1( "method" ),
 		"mixed testWidget1", "testWidget1 mixin successful" );
-	equal( $( "<div>" ).testWidget2().testWidget2( "method" ),
+	assert.equal( $( "<div>" ).testWidget2().testWidget2( "method" ),
 		"mixed testWidget2", "testWidget2 mixin successful" );
 } );
 
-asyncTest( "_delay", function() {
-	expect( 6 );
+QUnit.test( "_delay", function( assert ) {
+	var ready = assert.async();
+	assert.expect( 6 );
 	var order = 0,
 		that;
 	$.widget( "ui.testWidget", {
@@ -1560,74 +1562,74 @@ asyncTest( "_delay", function() {
 		_create: function() {
 			that = this;
 			var timer = this._delay( function() {
-				strictEqual( this, that );
-				equal( order, 1 );
-				start();
+				assert.strictEqual( this, that );
+				assert.equal( order, 1 );
+				ready();
 			}, 500 );
-			ok( timer !== undefined );
+			assert.ok( timer !== undefined );
 			timer = this._delay( "callback" );
-			ok( timer !== undefined );
+			assert.ok( timer !== undefined );
 		},
 		callback: function() {
-			strictEqual( this, that );
-			equal( order, 0 );
+			assert.strictEqual( this, that );
+			assert.equal( order, 0 );
 			order += 1;
 		}
 	} );
 	$( "#widget" ).testWidget();
 } );
 
-test( "$.widget.bridge()", function() {
-	expect( 14 );
+QUnit.test( "$.widget.bridge()", function( assert ) {
+	assert.expect( 14 );
 
 	var instance, ret,
 		elem = $( "<div>" );
 
 	function TestWidget( options, element ) {
-		deepEqual( options, { foo: "bar" }, "options passed" );
-		strictEqual( element, elem[ 0 ], "element passed" );
+		assert.deepEqual( options, { foo: "bar" }, "options passed" );
+		assert.strictEqual( element, elem[ 0 ], "element passed" );
 	}
 
 	$.extend( TestWidget.prototype, {
 		method: function( param ) {
-			ok( true, "method called via .pluginName(methodName)" );
-			equal( param, "value1",
+			assert.ok( true, "method called via .pluginName(methodName)" );
+			assert.equal( param, "value1",
 				"parameter passed via .pluginName(methodName, param)" );
 		},
 		getter: function() {
 			return "qux";
 		},
 		option: function( options ) {
-			deepEqual( options, {} );
+			assert.deepEqual( options, {} );
 		}
 	} );
 
 	$.widget.bridge( "testWidget", TestWidget );
 
-	ok( $.isFunction( $.fn.testWidget ), "jQuery plugin was created" );
+	assert.ok( $.isFunction( $.fn.testWidget ), "jQuery plugin was created" );
 
-	strictEqual( elem.testWidget( { foo: "bar" } ), elem, "plugin returns original jQuery object" );
+	assert.strictEqual( elem.testWidget( { foo: "bar" } ), elem, "plugin returns original jQuery object" );
 	instance = elem.data( "testWidget" );
-	equal( typeof instance, "object", "instance stored in .data(pluginName)" );
-	equal( typeof elem.testWidget( "instance" ), "object", "also retrievable via instance method" );
+	assert.equal( typeof instance, "object", "instance stored in .data(pluginName)" );
+	assert.equal( typeof elem.testWidget( "instance" ), "object", "also retrievable via instance method" );
 
 	ret = elem.testWidget( "method", "value1" );
-	equal( ret, elem, "jQuery object returned from method call" );
+	assert.equal( ret, elem, "jQuery object returned from method call" );
 
 	ret = elem.testWidget( "getter" );
-	equal( ret, "qux", "getter returns value" );
+	assert.equal( ret, "qux", "getter returns value" );
 
 	elem.testWidget();
-	ok( true, "_init is optional" );
+	assert.ok( true, "_init is optional" );
 
 	TestWidget.prototype._init = function() {
-		ok( "_init", "_init now exists, so its called" );
+		assert.ok( "_init", "_init now exists, so its called" );
 	};
 	elem.testWidget();
 } );
 
-test( "$.widget.bridge() - widgetFullName", function() {
-	expect( 1 );
+QUnit.test( "$.widget.bridge() - widgetFullName", function( assert ) {
+	assert.expect( 1 );
 
 	var instance,
 		elem = $( "<div>" );
@@ -1638,7 +1640,7 @@ test( "$.widget.bridge() - widgetFullName", function() {
 
 	elem.testWidget();
 	instance = elem.data( "custom-widget" );
-	equal( typeof instance, "object", "instance stored in .data(widgetFullName)" );
+	assert.equal( typeof instance, "object", "instance stored in .data(widgetFullName)" );
 } );
 
 } );
diff --git a/tests/unit/widget/extend.js b/tests/unit/widget/extend.js
index 93afd731a..36575200b 100644
--- a/tests/unit/widget/extend.js
+++ b/tests/unit/widget/extend.js
@@ -1,10 +1,11 @@
 define( [
+	"qunit",
 	"jquery",
 	"ui/widget"
-], function( $ ) {
+], function( QUnit, $ ) {
 
-test( "$.widget.extend()", function() {
-	expect( 27 );
+QUnit.test( "$.widget.extend()", function( assert ) {
+	assert.expect( 27 );
 
 	var ret, empty, optionsWithLength, optionsWithDate, myKlass, customObject, optionsWithCustomObject, nullUndef,
 		target, recursive, obj, input, output,
@@ -27,86 +28,86 @@ test( "$.widget.extend()", function() {
 		merged2 = { xnumber1: 5, xnumber2: 1, xstring1: "peter", xstring2: "xx", xxx: "newstringx" };
 
 	$.widget.extend( settings, options );
-	deepEqual( settings, merged, "Check if extended: settings must be extended" );
-	deepEqual( options, optionsCopy, "Check if not modified: options must not be modified" );
+	assert.deepEqual( settings, merged, "Check if extended: settings must be extended" );
+	assert.deepEqual( options, optionsCopy, "Check if not modified: options must not be modified" );
 
 	$.widget.extend( deep1, deep2 );
-	deepEqual( deep1.foo, deepmerged.foo, "Check if foo: settings must be extended" );
-	deepEqual( deep2.foo, deep2copy.foo, "Check if not deep2: options must not be modified" );
-	equal( deep1.foo2, document, "Make sure that a deep clone was not attempted on the document" );
+	assert.deepEqual( deep1.foo, deepmerged.foo, "Check if foo: settings must be extended" );
+	assert.deepEqual( deep2.foo, deep2copy.foo, "Check if not deep2: options must not be modified" );
+	assert.equal( deep1.foo2, document, "Make sure that a deep clone was not attempted on the document" );
 
-	strictEqual( $.widget.extend( {}, nestedarray ).arr, arr, "Don't clone arrays" );
-	ok( $.isPlainObject( $.widget.extend( { arr: arr }, { arr: {} } ).arr ), "Cloned object heve to be an plain object" );
+	assert.strictEqual( $.widget.extend( {}, nestedarray ).arr, arr, "Don't clone arrays" );
+	assert.ok( $.isPlainObject( $.widget.extend( { arr: arr }, { arr: {} } ).arr ), "Cloned object heve to be an plain object" );
 
 	empty = {};
 	optionsWithLength = { foo: { length: -1 } };
 	$.widget.extend( empty, optionsWithLength );
-	deepEqual( empty.foo, optionsWithLength.foo, "The length property must copy correctly" );
+	assert.deepEqual( empty.foo, optionsWithLength.foo, "The length property must copy correctly" );
 
 	empty = {};
 	optionsWithDate = { foo: { date: new Date() } };
 	$.widget.extend( empty, optionsWithDate );
-	deepEqual( empty.foo, optionsWithDate.foo, "Dates copy correctly" );
+	assert.deepEqual( empty.foo, optionsWithDate.foo, "Dates copy correctly" );
 
 	myKlass = function() {};
 	customObject = new myKlass();
 	optionsWithCustomObject = { foo: { date: customObject } };
 	empty = {};
 	$.widget.extend( empty, optionsWithCustomObject );
-	strictEqual( empty.foo.date, customObject, "Custom objects copy correctly (no methods)" );
+	assert.strictEqual( empty.foo.date, customObject, "Custom objects copy correctly (no methods)" );
 
 	// Makes the class a little more realistic
 	myKlass.prototype = { someMethod: function() {} };
 	empty = {};
 	$.widget.extend( empty, optionsWithCustomObject );
-	strictEqual( empty.foo.date, customObject, "Custom objects copy correctly" );
+	assert.strictEqual( empty.foo.date, customObject, "Custom objects copy correctly" );
 
 	ret = $.widget.extend( { foo: 4 }, { foo: Number( 5 ) } );
-	equal( ret.foo, 5, "Wrapped numbers copy correctly" );
+	assert.equal( ret.foo, 5, "Wrapped numbers copy correctly" );
 
 	nullUndef = $.widget.extend( {}, options, { xnumber2: null } );
-	strictEqual( nullUndef.xnumber2, null, "Check to make sure null values are copied" );
+	assert.strictEqual( nullUndef.xnumber2, null, "Check to make sure null values are copied" );
 
 	nullUndef = $.widget.extend( {}, options, { xnumber2: undefined } );
-	strictEqual( nullUndef.xnumber2, options.xnumber2, "Check to make sure undefined values are not copied" );
+	assert.strictEqual( nullUndef.xnumber2, options.xnumber2, "Check to make sure undefined values are not copied" );
 
 	nullUndef = $.widget.extend( {}, options, { xnumber0: null } );
-	strictEqual( nullUndef.xnumber0, null, "Check to make sure null values are inserted" );
+	assert.strictEqual( nullUndef.xnumber0, null, "Check to make sure null values are inserted" );
 
 	target = {};
 	recursive = { foo:target, bar:5 };
 	$.widget.extend( target, recursive );
-	deepEqual( target, { foo: {}, bar: 5 }, "Check to make sure a recursive obj doesn't go never-ending loop by not copying it over" );
+	assert.deepEqual( target, { foo: {}, bar: 5 }, "Check to make sure a recursive obj doesn't go never-ending loop by not copying it over" );
 
 	ret = $.widget.extend( { foo: [] }, { foo: [ 0 ] } ); // 1907
-	equal( ret.foo.length, 1, "Check to make sure a value with coersion 'false' copies over when necessary to fix #1907" );
+	assert.equal( ret.foo.length, 1, "Check to make sure a value with coersion 'false' copies over when necessary to fix #1907" );
 
 	ret = $.widget.extend( { foo: "1,2,3" }, { foo: [ 1, 2, 3 ] } );
-	deepEqual( ret.foo, [ 1, 2, 3 ], "Properly extend a string to array." );
+	assert.deepEqual( ret.foo, [ 1, 2, 3 ], "Properly extend a string to array." );
 
 	ret = $.widget.extend( { foo: "1,2,3" }, { foo: { to: "object" } } );
-	deepEqual( ret.foo, { to: "object" }, "Properly extend a string to object." );
+	assert.deepEqual( ret.foo, { to: "object" }, "Properly extend a string to object." );
 
 	ret = $.widget.extend( { foo: "bar" }, { foo: null } );
-	strictEqual( ret.foo, null, "Make sure a null value doesn't crash with deep extend, for #1908" );
+	assert.strictEqual( ret.foo, null, "Make sure a null value doesn't crash with deep extend, for #1908" );
 
 	obj = { foo: null };
 	$.widget.extend( obj, { foo:"notnull" } );
-	equal( obj.foo, "notnull", "Make sure a null value can be overwritten" );
+	assert.equal( obj.foo, "notnull", "Make sure a null value can be overwritten" );
 
 	settings = $.widget.extend( {}, defaults, options1, options2 );
-	deepEqual( settings, merged2, "Check if extended: settings must be extended" );
-	deepEqual( defaults, defaultsCopy, "Check if not modified: options1 must not be modified" );
-	deepEqual( options1, options1Copy, "Check if not modified: options1 must not be modified" );
-	deepEqual( options2, options2Copy, "Check if not modified: options2 must not be modified" );
+	assert.deepEqual( settings, merged2, "Check if extended: settings must be extended" );
+	assert.deepEqual( defaults, defaultsCopy, "Check if not modified: options1 must not be modified" );
+	assert.deepEqual( options1, options1Copy, "Check if not modified: options1 must not be modified" );
+	assert.deepEqual( options2, options2Copy, "Check if not modified: options2 must not be modified" );
 
 	input = {
 		key: [ 1, 2, 3 ]
 	};
 	output = $.widget.extend( {}, input );
-	deepEqual( input, output, "don't clone arrays" );
+	assert.deepEqual( input, output, "don't clone arrays" );
 	input.key[ 0 ] = 10;
-	deepEqual( input, output, "don't clone arrays" );
+	assert.deepEqual( input, output, "don't clone arrays" );
 } );
 
 } );