Spinner: Shift to use no globals

1 files changed, 67 insertions, 66 deletions

diff --git a/tests/unit/spinner/methods.js b/tests/unit/spinner/methods.js
index 3b039ff39..a7af2956d 100644
--- a/tests/unit/spinner/methods.js
+++ b/tests/unit/spinner/methods.js
@@ -1,211 +1,212 @@
 define( [
+	"qunit",
 	"jquery",
 	"./helper",
 	"ui/widgets/spinner"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
 
 var simulateKeyDownUp = testHelper.simulateKeyDownUp;
 
-module( "spinner: methods" );
+QUnit.module( "spinner: methods" );
 
-test( "destroy", function( assert ) {
-	expect( 1 );
+QUnit.test( "destroy", function( assert ) {
+	assert.expect( 1 );
 	assert.domEqual( "#spin", function() {
 		$( "#spin" ).spinner().spinner( "destroy" );
 	} );
 } );
 
-test( "disable", function( assert ) {
-	expect( 15 );
+QUnit.test( "disable", function( assert ) {
+	assert.expect( 15 );
 	var element = $( "#spin" ).val( 2 ).spinner(),
 		wrapper = $( "#spin" ).spinner( "widget" );
 
 	assert.lacksClasses( wrapper, "ui-spinner-disabled" );
-	ok( !element.is( ":disabled" ), "before: input does not have disabled attribute" );
+	assert.ok( !element.is( ":disabled" ), "before: input does not have disabled attribute" );
 
 	element.spinner( "disable" );
 	assert.hasClasses( wrapper, "ui-state-disabled ui-spinner-disabled" );
-	ok( !wrapper.attr( "aria-disabled" ), "after: wrapper does not have aria-disabled attr" );
-	ok( element.is( ":disabled" ), "after: input has disabled attribute" );
+	assert.ok( !wrapper.attr( "aria-disabled" ), "after: wrapper does not have aria-disabled attr" );
+	assert.ok( element.is( ":disabled" ), "after: input has disabled attribute" );
 
 	simulateKeyDownUp( element, $.ui.keyCode.UP );
-	equal( 2, element.val(), "keyboard - value does not change on key UP" );
+	assert.equal( 2, element.val(), "keyboard - value does not change on key UP" );
 
 	simulateKeyDownUp( element, $.ui.keyCode.DOWN );
-	equal( 2, element.val(), "keyboard - value does not change on key DOWN" );
+	assert.equal( 2, element.val(), "keyboard - value does not change on key DOWN" );
 
 	simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
-	equal( 2, element.val(), "keyboard - value does not change on key PGUP" );
+	assert.equal( 2, element.val(), "keyboard - value does not change on key PGUP" );
 
 	simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
-	equal( 2, element.val(), "keyboard - value does not change on key PGDN" );
+	assert.equal( 2, element.val(), "keyboard - value does not change on key PGDN" );
 
 	wrapper.find( ".ui-spinner-up" ).trigger( "mousedown" ).trigger( "mouseup" );
-	equal( 2, element.val(), "mouse - value does not change on clicking up button" );
+	assert.equal( 2, element.val(), "mouse - value does not change on clicking up button" );
 
 	wrapper.find( ".ui-spinner-down" ).trigger( "mousedown" ).trigger( "mouseup" );
-	equal( 2, element.val(), "mouse - value does not change on clicking down button" );
+	assert.equal( 2, element.val(), "mouse - value does not change on clicking down button" );
 
 	element.spinner( "stepUp", 6 );
-	equal( 8, element.val(), "script - stepUp 6 steps changes value" );
+	assert.equal( 8, element.val(), "script - stepUp 6 steps changes value" );
 
 	element.spinner( "stepDown" );
-	equal( 7, element.val(), "script - stepDown 1 step changes value" );
+	assert.equal( 7, element.val(), "script - stepDown 1 step changes value" );
 
 	element.spinner( "pageUp" );
-	equal( 17, element.val(), "script - pageUp 1 page changes value" );
+	assert.equal( 17, element.val(), "script - pageUp 1 page changes value" );
 
 	element.spinner( "pageDown" );
-	equal( 7, element.val(), "script - pageDown 1 page changes value" );
+	assert.equal( 7, element.val(), "script - pageDown 1 page changes value" );
 } );
 
-test( "enable", function( assert ) {
-	expect( 5 );
+QUnit.test( "enable", function( assert ) {
+	assert.expect( 5 );
 	var element = $( "#spin" ).val( 1 ).spinner( { disabled: true } ),
 		wrapper = element.spinner( "widget" );
 
 	assert.hasClasses( wrapper, "ui-spinner-disabled" );
-	ok( element.is( ":disabled" ), "before: input has disabled attribute" );
+	assert.ok( element.is( ":disabled" ), "before: input has disabled attribute" );
 
 	element.spinner( "enable" );
 
 	assert.lacksClasses( wrapper, "ui-spinner-disabled" );
-	ok( !element.is( ":disabled" ), "after: input does not have disabled attribute" );
+	assert.ok( !element.is( ":disabled" ), "after: input does not have disabled attribute" );
 
 	simulateKeyDownUp( element, $.ui.keyCode.UP );
-	equal( 2, element.val(), "keyboard - value changes on key UP" );
+	assert.equal( 2, element.val(), "keyboard - value changes on key UP" );
 } );
 
-test( "isValid", function() {
-	expect( 8 );
+QUnit.test( "isValid", function( assert ) {
+	assert.expect( 8 );
 	var element = $( "#spin" ).spinner( {
 			min: 0,
 			max: 10,
 			step: 2
 		} ),
 		spinner = element.spinner( "instance" );
-	ok( !spinner.isValid(), "initial state is invalid" );
+	assert.ok( !spinner.isValid(), "initial state is invalid" );
 
 	element.val( "this is not a number" );
-	ok( !spinner.isValid(), "text string is not valid" );
+	assert.ok( !spinner.isValid(), "text string is not valid" );
 
 	element.val( "0" );
-	ok( spinner.isValid(), "min value is valid" );
+	assert.ok( spinner.isValid(), "min value is valid" );
 
 	element.val( "10" );
-	ok( spinner.isValid(), "max value is valid" );
+	assert.ok( spinner.isValid(), "max value is valid" );
 
 	element.val( "4" );
-	ok( spinner.isValid(), "inbetween step is valid" );
+	assert.ok( spinner.isValid(), "inbetween step is valid" );
 
 	element.val( "-1" );
-	ok( !spinner.isValid(), "below min is invalid" );
+	assert.ok( !spinner.isValid(), "below min is invalid" );
 
 	element.val( "11" );
-	ok( !spinner.isValid(), "above max is invalid" );
+	assert.ok( !spinner.isValid(), "above max is invalid" );
 
 	element.val( "1" );
-	ok( !spinner.isValid(), "step mismatch is invalid" );
+	assert.ok( !spinner.isValid(), "step mismatch is invalid" );
 } );
 
-test( "pageDown", function() {
-	expect( 4 );
+QUnit.test( "pageDown", function( assert ) {
+	assert.expect( 4 );
 	var element = $( "#spin" ).val( -12 ).spinner( {
 		page: 20,
 		min: -100
 	} );
 
 	element.spinner( "pageDown" );
-	equal( element.val(), -32, "pageDown 1 page" );
+	assert.equal( element.val(), -32, "pageDown 1 page" );
 
 	element.spinner( "pageDown", 3 );
-	equal( element.val(), -92, "pageDown 3 pages" );
+	assert.equal( element.val(), -92, "pageDown 3 pages" );
 
 	element.spinner( "pageDown" );
-	equal( element.val(), -100, "value close to min and pageDown 1 page" );
+	assert.equal( element.val(), -100, "value close to min and pageDown 1 page" );
 
 	element.spinner( "pageDown", 10 );
-	equal( element.val(), -100, "value at min and pageDown 10 pages" );
+	assert.equal( element.val(), -100, "value at min and pageDown 10 pages" );
 } );
 
-test( "pageUp", function() {
-	expect( 4 );
+QUnit.test( "pageUp", function( assert ) {
+	assert.expect( 4 );
 	var element = $( "#spin" ).val( 12 ).spinner( {
 		page: 20,
 		max: 100
 	} );
 
 	element.spinner( "pageUp" );
-	equal( element.val(), 32, "pageUp 1 page" );
+	assert.equal( element.val(), 32, "pageUp 1 page" );
 
 	element.spinner( "pageUp", 3 );
-	equal( element.val(), 92, "pageUp 3 pages" );
+	assert.equal( element.val(), 92, "pageUp 3 pages" );
 
 	element.spinner( "pageUp" );
-	equal( element.val(), 100, "value close to max and pageUp 1 page" );
+	assert.equal( element.val(), 100, "value close to max and pageUp 1 page" );
 
 	element.spinner( "pageUp", 10 );
-	equal( element.val(), 100, "value at max and pageUp 10 pages" );
+	assert.equal( element.val(), 100, "value at max and pageUp 10 pages" );
 } );
 
-test( "stepDown", function() {
-	expect( 4 );
+QUnit.test( "stepDown", function( assert ) {
+	assert.expect( 4 );
 	var element = $( "#spin" ).val( 0 ).spinner( {
 		step: 2,
 		min: -15
 	} );
 
 	element.spinner( "stepDown" );
-	equal( element.val(), "-1", "stepDown 1 step" );
+	assert.equal( element.val(), "-1", "stepDown 1 step" );
 
 	element.spinner( "stepDown", 5 );
-	equal( element.val(), "-11", "stepDown 5 steps" );
+	assert.equal( element.val(), "-11", "stepDown 5 steps" );
 
 	element.spinner( "stepDown", 4 );
-	equal( element.val(), "-15", "close to min and stepDown 4 steps" );
+	assert.equal( element.val(), "-15", "close to min and stepDown 4 steps" );
 
 	element.spinner( "stepDown" );
-	equal( element.val(), "-15", "at min and stepDown 1 step" );
+	assert.equal( element.val(), "-15", "at min and stepDown 1 step" );
 } );
 
-test( "stepUp", function() {
-	expect( 4 );
+QUnit.test( "stepUp", function( assert ) {
+	assert.expect( 4 );
 	var element = $( "#spin" ).val( 0 ).spinner( {
 		step: 2,
 		max: 16
 	} );
 
 	element.spinner( "stepUp" );
-	equal( element.val(), 2, "stepUp 1 step" );
+	assert.equal( element.val(), 2, "stepUp 1 step" );
 
 	element.spinner( "stepUp", 5 );
-	equal( element.val(), 12, "stepUp 5 steps" );
+	assert.equal( element.val(), 12, "stepUp 5 steps" );
 
 	element.spinner( "stepUp", 4 );
-	equal( element.val(), 16, "close to max and stepUp 4 steps" );
+	assert.equal( element.val(), 16, "close to max and stepUp 4 steps" );
 
 	element.spinner( "stepUp" );
-	equal( element.val(), 16, "at max and stepUp 1 step" );
+	assert.equal( element.val(), 16, "at max and stepUp 1 step" );
 } );
 
-test( "value", function() {
-	expect( 2 );
+QUnit.test( "value", function( assert ) {
+	assert.expect( 2 );
 	var element = $( "#spin" ).val( 0 ).spinner( {
 		step: 3
 	} );
 
 	element.spinner( "value", 10 );
-	equal( element.val(), 9, "change value via value method" );
+	assert.equal( element.val(), 9, "change value via value method" );
 
-	equal( element.spinner( "value" ), 9, "get value via value method" );
+	assert.equal( element.spinner( "value" ), 9, "get value via value method" );
 } );
 
-test( "widget", function() {
-	expect( 2 );
+QUnit.test( "widget", function( assert ) {
+	assert.expect( 2 );
 	var element = $( "#spin" ).spinner(),
 		widgetElement = element.spinner( "widget" );
-	equal( widgetElement.length, 1, "one element" );
-	strictEqual( widgetElement[ 0 ], element.parent()[ 0 ], "parent element" );
+	assert.equal( widgetElement.length, 1, "one element" );
+	assert.strictEqual( widgetElement[ 0 ], element.parent()[ 0 ], "parent element" );
 } );
 
 } );