" ).slider( { range: true } ),
handle = element.find( "span" ),
range = element.find( "div" );
@@ -24,8 +25,8 @@ test( "markup structure", function( assert ) {
assert.hasClasses( handle[ 1 ], "ui-slider-handle" );
} );
-test( "keydown HOME on handle sets value to min", function() {
- expect( 2 );
+QUnit.test( "keydown HOME on handle sets value to min", function( assert ) {
+ assert.expect( 2 );
element = $( "
" );
options = {
max: 5,
@@ -38,7 +39,7 @@ test( "keydown HOME on handle sets value to min", function() {
element.slider( "value", 0 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.HOME } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
element.slider( "destroy" );
@@ -54,13 +55,13 @@ test( "keydown HOME on handle sets value to min", function() {
element.slider( "value", 0 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.HOME } );
- equal( element.slider( "value" ), options.min ) ;
+ assert.equal( element.slider( "value" ), options.min ) ;
element.slider( "destroy" );
} );
-test( "keydown END on handle sets value to max", function() {
- expect( 2 );
+QUnit.test( "keydown END on handle sets value to max", function( assert ) {
+ assert.expect( 2 );
element = $( "
" );
options = {
max: 5,
@@ -73,7 +74,7 @@ test( "keydown END on handle sets value to max", function() {
element.slider( "value", 0 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.END } );
- equal( element.slider( "value" ), options.max ) ;
+ assert.equal( element.slider( "value" ), options.max ) ;
element.slider( "destroy" );
@@ -89,13 +90,13 @@ test( "keydown END on handle sets value to max", function() {
element.slider( "value", 0 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.END } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
element.slider( "destroy" );
} );
-test( "keydown PAGE_UP on handle increases value by 1/5 range, not greater than max", function() {
- expect( 4 );
+QUnit.test( "keydown PAGE_UP on handle increases value by 1/5 range, not greater than max", function( assert ) {
+ assert.expect( 4 );
$.each( [ "horizontal", "vertical" ], function( i, orientation ) {
element = $( "
" );
options = {
@@ -109,17 +110,17 @@ test( "keydown PAGE_UP on handle increases value by 1/5 range, not greater than
element.slider( "value", 70 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
- equal( element.slider( "value" ), 90 );
+ assert.equal( element.slider( "value" ), 90 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
- equal( element.slider( "value" ), 100 );
+ assert.equal( element.slider( "value" ), 100 );
element.slider( "destroy" );
} );
} );
-test( "keydown PAGE_DOWN on handle decreases value by 1/5 range, not less than min", function() {
- expect( 4 );
+QUnit.test( "keydown PAGE_DOWN on handle decreases value by 1/5 range, not less than min", function( assert ) {
+ assert.expect( 4 );
$.each( [ "horizontal", "vertical" ], function( i, orientation ) {
element = $( "
" );
options = {
@@ -133,17 +134,17 @@ test( "keydown PAGE_DOWN on handle decreases value by 1/5 range, not less than m
element.slider( "value", 30 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
- equal( element.slider( "value" ), 10 );
+ assert.equal( element.slider( "value" ), 10 );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
- equal( element.slider( "value" ), 0 );
+ assert.equal( element.slider( "value" ), 0 );
element.slider( "destroy" );
} );
} );
-test( "keydown UP on handle increases value by step, not greater than max", function() {
- expect( 4 );
+QUnit.test( "keydown UP on handle increases value by step, not greater than max", function( assert ) {
+ assert.expect( 4 );
element = $( "
" );
options = {
max: 5,
@@ -156,10 +157,10 @@ test( "keydown UP on handle increases value by step, not greater than max", func
element.slider( "value", options.max - options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
element.slider( "destroy" );
@@ -175,16 +176,16 @@ test( "keydown UP on handle increases value by step, not greater than max", func
element.slider( "value", options.max - options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
element.slider( "destroy" );
} );
-test( "keydown RIGHT on handle increases value by step, not greater than max", function() {
- expect( 4 );
+QUnit.test( "keydown RIGHT on handle increases value by step, not greater than max", function( assert ) {
+ assert.expect( 4 );
element = $( "
" );
options = {
max: 5,
@@ -197,10 +198,10 @@ test( "keydown RIGHT on handle increases value by step, not greater than max", f
element.slider( "value", options.max - options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
element.slider( "destroy" );
@@ -216,16 +217,16 @@ test( "keydown RIGHT on handle increases value by step, not greater than max", f
element.slider( "value", options.max - options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
- equal( element.slider( "value" ), options.max );
+ assert.equal( element.slider( "value" ), options.max );
element.slider( "destroy" );
} );
-test( "keydown DOWN on handle decreases value by step, not less than min", function() {
- expect( 4 );
+QUnit.test( "keydown DOWN on handle decreases value by step, not less than min", function( assert ) {
+ assert.expect( 4 );
element = $( "
" );
options = {
max: 5,
@@ -238,10 +239,10 @@ test( "keydown DOWN on handle decreases value by step, not less than min", funct
element.slider( "value", options.min + options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
element.slider( "destroy" );
@@ -257,16 +258,16 @@ test( "keydown DOWN on handle decreases value by step, not less than min", funct
element.slider( "value", options.min + options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
element.slider( "destroy" );
} );
-test( "keydown LEFT on handle decreases value by step, not less than min", function() {
- expect( 4 );
+QUnit.test( "keydown LEFT on handle decreases value by step, not less than min", function( assert ) {
+ assert.expect( 4 );
element = $( "
" );
options = {
max: 5,
@@ -279,10 +280,10 @@ test( "keydown LEFT on handle decreases value by step, not less than min", funct
element.slider( "value", options.min + options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
element.slider( "destroy" );
@@ -298,10 +299,10 @@ test( "keydown LEFT on handle decreases value by step, not less than min", funct
element.slider( "value", options.min + options.step );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
- equal( element.slider( "value" ), options.min );
+ assert.equal( element.slider( "value" ), options.min );
element.slider( "destroy" );
} );
diff --git a/tests/unit/slider/events.js b/tests/unit/slider/events.js
index 2cf67b5fe17..d0459db64a4 100644
--- a/tests/unit/slider/events.js
+++ b/tests/unit/slider/events.js
@@ -1,30 +1,31 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/slider"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "slider: events" );
+QUnit.module( "slider: events" );
//Specs from http://wiki.jqueryui.com/Slider#specs
//"change callback: triggers when the slider has stopped moving and has a new
// value (even if same as previous value), via mouse(mouseup) or keyboard(keyup)
// or value method/option"
-test( "mouse based interaction", function() {
- expect( 4 );
+QUnit.test( "mouse based interaction", function( assert ) {
+ assert.expect( 4 );
var element = $( "#slider1" )
.slider( {
start: function( event ) {
- equal( event.originalEvent.type, "mousedown", "start triggered by mousedown" );
+ assert.equal( event.originalEvent.type, "mousedown", "start triggered by mousedown" );
},
slide: function( event ) {
- equal( event.originalEvent.type, "mousemove", "slider triggered by mousemove" );
+ assert.equal( event.originalEvent.type, "mousemove", "slider triggered by mousemove" );
},
stop: function( event ) {
- equal( event.originalEvent.type, "mouseup", "stop triggered by mouseup" );
+ assert.equal( event.originalEvent.type, "mouseup", "stop triggered by mouseup" );
},
change: function( event ) {
- equal( event.originalEvent.type, "mouseup", "change triggered by mouseup" );
+ assert.equal( event.originalEvent.type, "mouseup", "change triggered by mouseup" );
}
} );
@@ -32,23 +33,23 @@ test( "mouse based interaction", function() {
.simulate( "drag", { dx: 10, dy: 10 } );
} );
-test( "keyboard based interaction", function() {
- expect( 3 );
+QUnit.test( "keyboard based interaction", function( assert ) {
+ assert.expect( 3 );
// Test keyup at end of handle slide (keyboard)
var element = $( "#slider1" )
.slider( {
start: function( event ) {
- equal( event.originalEvent.type, "keydown", "start triggered by keydown" );
+ assert.equal( event.originalEvent.type, "keydown", "start triggered by keydown" );
},
slide: function() {
- ok( false, "Slider never triggered by keys" );
+ assert.ok( false, "Slider never triggered by keys" );
},
stop: function( event ) {
- equal( event.originalEvent.type, "keyup", "stop triggered by keyup" );
+ assert.equal( event.originalEvent.type, "keyup", "stop triggered by keyup" );
},
change: function( event ) {
- equal( event.originalEvent.type, "keyup", "change triggered by keyup" );
+ assert.equal( event.originalEvent.type, "keyup", "change triggered by keyup" );
}
} );
@@ -58,14 +59,14 @@ test( "keyboard based interaction", function() {
.simulate( "keyup", { keyCode: $.ui.keyCode.LEFT } );
} );
-test( "programmatic event triggers", function() {
- expect( 6 );
+QUnit.test( "programmatic event triggers", function( assert ) {
+ assert.expect( 6 );
// Test value method
var element = $( "
" )
.slider( {
change: function() {
- ok( true, "change triggered by value method" );
+ assert.ok( true, "change triggered by value method" );
}
} )
.slider( "value", 0 );
@@ -75,7 +76,7 @@ test( "programmatic event triggers", function() {
.slider( {
values: [ 10, 20 ],
change: function() {
- ok( true, "change triggered by values method" );
+ assert.ok( true, "change triggered by values method" );
}
} )
.slider( "values", [ 80, 90 ] );
@@ -84,7 +85,7 @@ test( "programmatic event triggers", function() {
element = $( "
" )
.slider( {
change: function() {
- ok( true, "change triggered by value option" );
+ assert.ok( true, "change triggered by value option" );
}
} )
.slider( "option", "value", 0 );
@@ -94,21 +95,21 @@ test( "programmatic event triggers", function() {
.slider( {
values: [ 10, 20 ],
change: function() {
- ok( true, "change triggered by values option" );
+ assert.ok( true, "change triggered by values option" );
}
} )
.slider( "option", "values", [ 80, 90 ] );
} );
-test( "mouse based interaction part two: when handles overlap", function() {
- expect( 6 );
+QUnit.test( "mouse based interaction part two: when handles overlap", function( assert ) {
+ assert.expect( 6 );
var element = $( "#slider1" )
.slider( {
values: [ 0, 0, 0 ],
start: function( event, ui ) {
- equal( handles.index( ui.handle ), 2, "rightmost handle activated when overlapping at minimum (#3736)" );
+ assert.equal( handles.index( ui.handle ), 2, "rightmost handle activated when overlapping at minimum (#3736)" );
}
} ),
handles = element.find( ".ui-slider-handle" );
@@ -120,7 +121,7 @@ test( "mouse based interaction part two: when handles overlap", function() {
values: [ 10, 10, 10 ],
max: 10,
start: function( event, ui ) {
- equal( handles.index( ui.handle ), 0, "leftmost handle activated when overlapping at maximum" );
+ assert.equal( handles.index( ui.handle ), 0, "leftmost handle activated when overlapping at maximum" );
}
} ),
handles = element.find( ".ui-slider-handle" );
@@ -134,7 +135,7 @@ test( "mouse based interaction part two: when handles overlap", function() {
handles = element.find( ".ui-slider-handle" );
handles.eq( 0 ).simulate( "drag", { dx: 10 } );
element.one( "slidestart", function( event, ui ) {
- equal( handles.index( ui.handle ), 0, "left handle activated if left was moved last" );
+ assert.equal( handles.index( ui.handle ), 0, "left handle activated if left was moved last" );
} );
handles.eq( 0 ).simulate( "drag", { dx: 10 } );
element.slider( "destroy" );
@@ -146,7 +147,7 @@ test( "mouse based interaction part two: when handles overlap", function() {
handles = element.find( ".ui-slider-handle" );
handles.eq( 1 ).simulate( "drag", { dx: -10 } );
element.one( "slidestart", function( event, ui ) {
- equal( handles.index( ui.handle ), 1, "right handle activated if right was moved last (#3467)" );
+ assert.equal( handles.index( ui.handle ), 1, "right handle activated if right was moved last (#3467)" );
} );
handles.eq( 0 ).simulate( "drag", { dx: 10 } );
@@ -161,15 +162,15 @@ test( "mouse based interaction part two: when handles overlap", function() {
element.slider( "option", { values: [ 100, 100 ] } );
handles.eq( 0 ).simulate( "drag", { dx: -10 } );
- equal( element.slider( "values" )[ 0 ], 99, "setting both values of range slider to the maximum doesn't lock slider" );
+ assert.equal( element.slider( "values" )[ 0 ], 99, "setting both values of range slider to the maximum doesn't lock slider" );
element.slider( "option", { values: [ 0, 0 ] } );
handles.eq( 1 ).simulate( "drag", { dx: 10 } );
- equal( element.slider( "values" )[ 1 ], 1, "setting both values of range slider to the minimum doesn't lock slider" );
+ assert.equal( element.slider( "values" )[ 1 ], 1, "setting both values of range slider to the minimum doesn't lock slider" );
} );
-test( "event data", function() {
- expect( 6 );
+QUnit.test( "event data", function( assert ) {
+ assert.expect( 6 );
var slideHandleIndex = 3,
values = [ 8, 9, 7, 4 ],
@@ -178,16 +179,16 @@ test( "event data", function() {
.slider( {
values: values,
start: function( event, ui ) {
- deepEqual( ui, expectedUiHash, "passing ui to start event" );
+ assert.deepEqual( ui, expectedUiHash, "passing ui to start event" );
},
slide: function( event, ui ) {
- deepEqual( ui, expectedChangedUiHash, "passing ui to slide event" );
+ assert.deepEqual( ui, expectedChangedUiHash, "passing ui to slide event" );
},
stop: function( event, ui ) {
- deepEqual( ui, expectedChangedUiHash, "passing ui to stop event" );
+ assert.deepEqual( ui, expectedChangedUiHash, "passing ui to stop event" );
},
change: function( event, ui ) {
- deepEqual( ui, expectedChangedUiHash, "passing ui to change event" );
+ assert.deepEqual( ui, expectedChangedUiHash, "passing ui to change event" );
}
} ),
handles = element.find( ".ui-slider-handle" ),
@@ -210,7 +211,7 @@ test( "event data", function() {
max: 100,
value: 1,
slide: function( event, ui ) {
- equal( ui.value, 0, "should pass 0 value if slider reaches it" );
+ assert.equal( ui.value, 0, "should pass 0 value if slider reaches it" );
}
} );
handles = element.find( ".ui-slider-handle" );
@@ -222,7 +223,7 @@ test( "event data", function() {
max: 100,
values: [ 1, 2 ],
slide: function( event, ui ) {
- equal( ui.value, 0, "should pass 0 value if one of handles reaches it" );
+ assert.equal( ui.value, 0, "should pass 0 value if one of handles reaches it" );
}
} );
handles = element.find( ".ui-slider-handle" );
diff --git a/tests/unit/slider/methods.js b/tests/unit/slider/methods.js
index 5c0cbb7bd3e..ea058cef22b 100644
--- a/tests/unit/slider/methods.js
+++ b/tests/unit/slider/methods.js
@@ -1,44 +1,45 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/slider"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "slider: methods" );
+QUnit.module( "slider: methods" );
-test( "init", function() {
- expect( 5 );
+QUnit.test( "init", function( assert ) {
+ assert.expect( 5 );
$( "
" ).appendTo( "body" ).slider().remove();
- ok( true, ".slider() called on element" );
+ assert.ok( true, ".slider() called on element" );
$( [] ).slider().remove();
- ok( true, ".slider() called on empty collection" );
+ assert.ok( true, ".slider() called on empty collection" );
$( "
" ).slider().remove();
- ok( true, ".slider() called on disconnected DOMElement" );
+ assert.ok( true, ".slider() called on disconnected DOMElement" );
var element = $( "
" ).slider();
element.slider( "option", "foo" );
element.remove();
- ok( true, "arbitrary option getter after init" );
+ assert.ok( true, "arbitrary option getter after init" );
$( "
" ).slider().slider( "option", "foo", "bar" ).remove();
- ok( true, "arbitrary option setter after init" );
+ assert.ok( true, "arbitrary option setter after init" );
} );
-test( "destroy", function( assert ) {
- expect( 1 );
+QUnit.test( "destroy", function( assert ) {
+ assert.expect( 1 );
assert.domEqual( "#slider1", function() {
$( "#slider1" ).slider().slider( "destroy" );
} );
} );
-test( "enable", function( assert ) {
- expect( 3 );
+QUnit.test( "enable", function( assert ) {
+ assert.expect( 3 );
var element,
expected = $( "
" ).slider(),
actual = expected.slider( "enable" );
- equal( actual, expected, "enable is chainable" );
+ assert.equal( actual, expected, "enable is chainable" );
element = $( "
" ).slider( { disabled: true } );
assert.hasClasses( element, "ui-state-disabled ui-slider-disabled" );
@@ -46,49 +47,49 @@ test( "enable", function( assert ) {
assert.lacksClasses( element, "ui-state-disabled ui-slider-disabled" );
} );
-test( "disable", function( assert ) {
- expect( 4 );
+QUnit.test( "disable", function( assert ) {
+ assert.expect( 4 );
var element,
expected = $( "
" ).slider(),
actual = expected.slider( "disable" );
- equal( actual, expected, "disable is chainable" );
+ assert.equal( actual, expected, "disable is chainable" );
element = $( "
" ).slider( { disabled: false } );
assert.lacksClasses( element, "ui-state-disabled ui-slider-disabled" );
element.slider( "disable" );
assert.hasClasses( element, "ui-state-disabled ui-slider-disabled" );
- ok( !element.attr( "aria-disabled" ), "slider does not have aria-disabled attr after disable method call" );
+ assert.ok( !element.attr( "aria-disabled" ), "slider does not have aria-disabled attr after disable method call" );
} );
-test( "value", function() {
- expect( 19 );
+QUnit.test( "value", function( assert ) {
+ assert.expect( 19 );
$( [ false, "min", "max" ] ).each( function() {
var element = $( "
" ).slider( {
range: this,
value: 5
} );
- equal( element.slider( "value" ), 5, "range: " + this + " slider method get" );
- equal( element.slider( "value", 10 ), element, "value method is chainable" );
- equal( element.slider( "value" ), 10, "range: " + this + " slider method set" );
+ assert.equal( element.slider( "value" ), 5, "range: " + this + " slider method get" );
+ assert.equal( element.slider( "value", 10 ), element, "value method is chainable" );
+ assert.equal( element.slider( "value" ), 10, "range: " + this + " slider method set" );
element.remove();
} );
var element = $( "
" ).slider( {
min: -1, value: 0, max: 1
} );
- // min with value option vs value method
+ // Min with value option vs value method
element.slider( "option", "value", -2 );
- equal( element.slider( "option", "value" ), -2, "value option does not respect min" );
- equal( element.slider( "value" ), -1, "value method get respects min" );
- equal( element.slider( "value", -2 ), element, "value method is chainable" );
- equal( element.slider( "option", "value" ), -1, "value method set respects min" );
+ assert.equal( element.slider( "option", "value" ), -2, "value option does not respect min" );
+ assert.equal( element.slider( "value" ), -1, "value method get respects min" );
+ assert.equal( element.slider( "value", -2 ), element, "value method is chainable" );
+ assert.equal( element.slider( "option", "value" ), -1, "value method set respects min" );
- // max with value option vs value method
+ // Max with value option vs value method
element.slider( "option", "value", 2 );
- equal( element.slider( "option", "value" ), 2, "value option does not respect max" );
- equal( element.slider( "value" ), 1, "value method get respects max" );
- equal( element.slider( "value", 2 ), element, "value method is chainable" );
- equal( element.slider( "option", "value" ), 1, "value method set respects max" );
+ assert.equal( element.slider( "option", "value" ), 2, "value option does not respect max" );
+ assert.equal( element.slider( "value" ), 1, "value method get respects max" );
+ assert.equal( element.slider( "value", 2 ), element, "value method is chainable" );
+ assert.equal( element.slider( "option", "value" ), 1, "value method set respects max" );
// Set max value with step 0.01
element.slider( "option", {
@@ -98,7 +99,7 @@ test( "value", function() {
step: 0.01
} );
element.slider( "option", "value", 2.4 );
- equal( element.slider( "value" ), 2.4, "value is set to max with 0.01 step" );
+ assert.equal( element.slider( "value" ), 2.4, "value is set to max with 0.01 step" );
element = $( "
" ).slider( {
value: 100,
@@ -108,11 +109,11 @@ test( "value", function() {
} );
element.slider( "option", "value", 510 );
- equal( element.slider( "value" ), 460, "value is restricted to maximum valid step" );
+ assert.equal( element.slider( "value" ), 460, "value is restricted to maximum valid step" );
} );
-test( "values, single step", function() {
- expect( 8 );
+QUnit.test( "values, single step", function( assert ) {
+ assert.expect( 8 );
var element = $( "
" ).slider( {
range: false,
@@ -122,29 +123,29 @@ test( "values, single step", function() {
values: [ 20 ]
} );
- deepEqual( element.slider( "values" ), [ 20 ], "range: false, values - get value for handle" );
- equal( element.slider( "values", 0 ), 20, "values (index) - get value of handle" );
+ assert.deepEqual( element.slider( "values" ), [ 20 ], "range: false, values - get value for handle" );
+ assert.equal( element.slider( "values", 0 ), 20, "values (index) - get value of handle" );
element.slider( "values", 0, 5 );
- equal( element.slider( "values", 0 ), 10, "values (index) - restrict against min" );
+ assert.equal( element.slider( "values", 0 ), 10, "values (index) - restrict against min" );
element.slider( "values", 0, 110 );
- equal( element.slider( "values", 0 ), 100, "values (index) - restrict against max" );
+ assert.equal( element.slider( "values", 0 ), 100, "values (index) - restrict against max" );
element.slider( "option", "range", true );
element.slider( "values", [ 20, 90 ] );
- deepEqual( element.slider( "values" ), [ 20, 90 ], "range: true, values - get value for all handles" );
- equal( element.slider( "values", 0 ), 20, "values (index) - 1st handle" );
- equal( element.slider( "values", 1 ), 90, "values (index) - 2nd handle" );
+ assert.deepEqual( element.slider( "values" ), [ 20, 90 ], "range: true, values - get value for all handles" );
+ assert.equal( element.slider( "values", 0 ), 20, "values (index) - 1st handle" );
+ assert.equal( element.slider( "values", 1 ), 90, "values (index) - 2nd handle" );
element.slider( "values", [ 5, 110 ] );
- deepEqual( element.slider( "values" ), [ 10, 100 ], "values - restricted against min and max" );
+ assert.deepEqual( element.slider( "values" ), [ 10, 100 ], "values - restricted against min and max" );
element.slider( "destroy" );
} );
-test( "values, multi step", function() {
- expect( 2 );
+QUnit.test( "values, multi step", function( assert ) {
+ assert.expect( 2 );
var element = $( "
" ).slider( {
range: false,
@@ -153,10 +154,10 @@ test( "values, multi step", function() {
step: 3,
values: [ 9, 12 ]
} );
- deepEqual( element.slider( "values" ), [ 9, 12 ], "values - evenly divisible by step" );
+ assert.deepEqual( element.slider( "values" ), [ 9, 12 ], "values - evenly divisible by step" );
element.slider( "values", [ 10, 20 ] );
- deepEqual( element.slider( "values" ), [ 9, 18 ], "values - not evenly divisible by step" );
+ assert.deepEqual( element.slider( "values" ), [ 9, 18 ], "values - not evenly divisible by step" );
element.slider( "destroy" );
} );
diff --git a/tests/unit/slider/options.js b/tests/unit/slider/options.js
index 5f3ea111134..d1eb2b374d6 100644
--- a/tests/unit/slider/options.js
+++ b/tests/unit/slider/options.js
@@ -1,7 +1,8 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/slider"
-], function( $ ) {
+], function( QUnit, $ ) {
var element, options;
@@ -9,10 +10,10 @@ function handle() {
return element.find( ".ui-slider-handle" );
}
-module( "slider: options" );
+QUnit.module( "slider: options" );
-test( "disabled", function( assert ) {
- expect( 8 );
+QUnit.test( "disabled", function( assert ) {
+ assert.expect( 8 );
var count = 0;
element = $( "#slider1" ).slider();
@@ -22,28 +23,28 @@ test( "disabled", function( assert ) {
// Enabled
assert.lacksClasses( element, "ui-slider-disabled" );
- equal( element.slider( "option", "disabled" ), false, "is not disabled" );
+ assert.equal( element.slider( "option", "disabled" ), false, "is not disabled" );
handle().simulate( "drag", { dx: 10 } );
- equal( count, 1, "slider moved" );
+ assert.equal( count, 1, "slider moved" );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
- equal( count, 2, "slider moved" );
+ assert.equal( count, 2, "slider moved" );
// Disabled
element.slider( "option", "disabled", true );
assert.hasClasses( element, "ui-slider-disabled" );
- equal( element.slider( "option", "disabled" ), true, "is disabled" );
+ assert.equal( element.slider( "option", "disabled" ), true, "is disabled" );
handle().simulate( "drag", { dx: 10 } );
- equal( count, 2, "slider did not move" );
+ assert.equal( count, 2, "slider did not move" );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
- equal( count, 2, "slider did not move" );
+ assert.equal( count, 2, "slider did not move" );
} );
-test( "max", function() {
- expect( 7 );
+QUnit.test( "max", function( assert ) {
+ assert.expect( 7 );
element = $( "
" );
options = {
@@ -55,8 +56,8 @@ test( "max", function() {
};
element.slider( options );
- ok( element.slider( "option", "value" ) === options.value, "value option is not contained by max" );
- ok( element.slider( "value" ) === options.max, "value method is contained by max" );
+ assert.ok( element.slider( "option", "value" ) === options.value, "value option is not contained by max" );
+ assert.ok( element.slider( "value" ) === options.max, "value method is contained by max" );
options = {
max: 9,
@@ -67,12 +68,12 @@ test( "max", function() {
};
element.slider( options );
- ok( element.slider( "value" ) === 7, "value method is within max, edge Case" );
+ assert.ok( element.slider( "value" ) === 7, "value method is within max, edge Case" );
options.step = 2;
element.slider( options );
- ok( element.slider( "value" ) === options.max, "value method will max, step is changed" );
+ assert.ok( element.slider( "value" ) === options.max, "value method will max, step is changed" );
element.slider( "destroy" );
options = {
@@ -84,7 +85,7 @@ test( "max", function() {
};
element.slider( options );
- ok( element.slider( "value" ) === options.max, "value method will max, step is changed and step is float" );
+ assert.ok( element.slider( "value" ) === options.max, "value method will max, step is changed and step is float" );
element.slider( "destroy" );
options = {
@@ -96,18 +97,18 @@ test( "max", function() {
};
element.slider( options );
- ok( element.slider( "value" ) === options.max, "value method will max, step is changed, step is float and max is float" );
+ assert.ok( element.slider( "value" ) === options.max, "value method will max, step is changed, step is float and max is float" );
element.slider( "destroy" );
options.max = 10.749999999;
element.slider( options );
- ok( element.slider( "value" ) === 10.74, "value method will max, step is changed, step is float, max is float and not divisible" );
+ assert.ok( element.slider( "value" ) === 10.74, "value method will max, step is changed, step is float, max is float and not divisible" );
element.slider( "destroy" );
} );
-test( "min", function() {
- expect( 2 );
+QUnit.test( "min", function( assert ) {
+ assert.expect( 2 );
element = $( "
" );
options = {
@@ -119,14 +120,14 @@ test( "min", function() {
};
element.slider( options );
- ok( element.slider( "option", "value" ) === options.value, "value option is not contained by min" );
- ok( element.slider( "value" ) === options.min, "value method is contained by min" );
+ assert.ok( element.slider( "option", "value" ) === options.value, "value option is not contained by min" );
+ assert.ok( element.slider( "value" ) === options.min, "value method is contained by min" );
element.slider( "destroy" );
} );
-test( "orientation", function( assert ) {
- expect( 14 );
+QUnit.test( "orientation", function( assert ) {
+ assert.expect( 14 );
element = $( "#slider1" );
options = {
@@ -142,8 +143,8 @@ test( "orientation", function( assert ) {
element.slider( options ).slider( "option", "orientation", "horizontal" );
assert.hasClasses( element, "ui-slider-horizontal" );
assert.lacksClasses( element, "ui-slider-vertical" );
- equal( element.find( ".ui-slider-handle" )[ 0 ].style.bottom, "", "CSS bottom reset" );
- equal( handle()[ 0 ].style.left, percentVal + "%", "horizontal slider handle is positioned with left: %" );
+ assert.equal( element.find( ".ui-slider-handle" )[ 0 ].style.bottom, "", "CSS bottom reset" );
+ assert.equal( handle()[ 0 ].style.left, percentVal + "%", "horizontal slider handle is positioned with left: %" );
element.slider( "destroy" ) ;
@@ -159,8 +160,8 @@ test( "orientation", function( assert ) {
element.slider( options ).slider( "option", "orientation", "vertical" );
assert.hasClasses( element, "ui-slider-vertical" );
assert.lacksClasses( element, "ui-slider-horizontal" );
- equal( element.find( ".ui-slider-handle" )[ 0 ].style.left, "", "CSS left reset" );
- equal( handle()[ 0 ].style.bottom, percentVal + "%", "vertical slider handle is positioned with bottom: %" );
+ assert.equal( element.find( ".ui-slider-handle" )[ 0 ].style.left, "", "CSS left reset" );
+ assert.equal( handle()[ 0 ].style.bottom, percentVal + "%", "vertical slider handle is positioned with bottom: %" );
element.slider( "destroy" );
@@ -174,15 +175,15 @@ test( "orientation", function( assert ) {
element.slider( "option", "value", newValue );
element.slider( "option", "orientation", "vertical" );
- equal( element.find( ".ui-slider-range" ).width(), 12,
+ assert.equal( element.find( ".ui-slider-range" ).width(), 12,
"range should occupy all horizontal space after changing orientation to vertical" );
- equal( element.find( ".ui-slider-range" ).height(), rangeSize,
+ assert.equal( element.find( ".ui-slider-range" ).height(), rangeSize,
"range height of vertical slider should be proportional to the value" );
element.slider( "option", "orientation", "horizontal" );
- equal( element.find( ".ui-slider-range " ).height(), 12,
+ assert.equal( element.find( ".ui-slider-range " ).height(), 12,
"range should occupy all vertical space after changing orientation to horizontal" );
- equal( element.find( ".ui-slider-range" ).width(), rangeSize,
+ assert.equal( element.find( ".ui-slider-range" ).width(), rangeSize,
"range width of horizontal slider should be proportional to the value" );
element.slider( "destroy" );
@@ -193,10 +194,10 @@ test( "orientation", function( assert ) {
max: 100
} );
element.slider( "option", { values: [ 60, 70 ] } );
- notEqual( element.find( ".ui-slider-range " ).position().left, 0,
+ assert.notEqual( element.find( ".ui-slider-range " ).position().left, 0,
"range should not pull over to the track's border" );
element.slider( "option", "orientation", "vertical" );
- equal( element.find( ".ui-slider-range " ).position().left, 0,
+ assert.equal( element.find( ".ui-slider-range " ).position().left, 0,
"range should pull over to the track's border" );
element.slider( "destroy" );
@@ -205,27 +206,27 @@ test( "orientation", function( assert ) {
//spec: http://wiki.jqueryui.com/Slider#specs
// value option/method: the value option is not restricted by min/max/step.
// What is returned by the value method is restricted by min (>=), max (<=), and step (even multiple)
-test( "step", function() {
- expect( 9 );
+QUnit.test( "step", function( assert ) {
+ assert.expect( 9 );
element = $( "
" ).slider( {
min: 0,
value: 0,
step: 10,
max: 100
} );
- equal( element.slider( "value" ), 0 );
+ assert.equal( element.slider( "value" ), 0 );
element.slider( "value", 1 );
- equal( element.slider( "value" ), 0 );
+ assert.equal( element.slider( "value" ), 0 );
element.slider( "value", 9 );
- equal( element.slider( "value" ), 10 );
+ assert.equal( element.slider( "value" ), 10 );
element.slider( "value", 11 );
- equal( element.slider( "value" ), 10 );
+ assert.equal( element.slider( "value" ), 10 );
element.slider( "value", 19 );
- equal( element.slider( "value" ), 20 );
+ assert.equal( element.slider( "value" ), 20 );
element = $( "
" ).slider( {
min: 0,
@@ -236,26 +237,26 @@ test( "step", function() {
element.slider( "value", 0 );
element.slider( "option", "value", 1 );
- equal( element.slider( "value" ), 0 );
+ assert.equal( element.slider( "value" ), 0 );
element.slider( "option", "value", 9 );
- equal( element.slider( "value" ), 0 );
+ assert.equal( element.slider( "value" ), 0 );
element.slider( "option", "value", 11 );
- equal( element.slider( "value" ), 20 );
+ assert.equal( element.slider( "value" ), 20 );
element.slider( "option", "value", 19 );
- equal( element.slider( "value" ), 20 );
+ assert.equal( element.slider( "value" ), 20 );
element.slider( "destroy" );
} );
-//test( "value", function() {
+//Test( "value", function() {
// ok(false, "missing test - untested code is broken code." );
//});
-test( "values", function() {
- expect( 2 );
+QUnit.test( "values", function( assert ) {
+ assert.expect( 2 );
// Testing multiple ranges on the same page, the object reference to the values
// property is preserved via multiple range elements, so updating options.values
@@ -268,7 +269,7 @@ test( "values", function() {
values: [ 25, 75 ]
} );
- notStrictEqual(
+ assert.notStrictEqual(
ranges.eq( 0 ).slider( "instance" ).options.values,
ranges.eq( 1 ).slider( "instance" ).options.values,
"multiple range sliders should not have a reference to the same options.values array"
@@ -276,15 +277,15 @@ test( "values", function() {
ranges.eq( 0 ).slider( "values", 0, 10 );
- notEqual(
+ assert.notEqual(
ranges.eq( 0 ).slider( "values", 0 ),
ranges.eq( 1 ).slider( "values", 0 ),
"the values for multiple sliders should be different"
);
} );
-test( "range", function( assert ) {
- expect( 32 );
+QUnit.test( "range", function( assert ) {
+ assert.expect( 32 );
var range;
// Min
@@ -295,8 +296,8 @@ test( "range", function( assert ) {
step: 1
} );
- equal( element.find( ".ui-slider-handle" ).length, 1, "range min, one handle" );
- equal( element.find( ".ui-slider-range-min" ).length, 1, "range min" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 1, "range min, one handle" );
+ assert.equal( element.find( ".ui-slider-range-min" ).length, 1, "range min" );
element.slider( "destroy" );
// Max
@@ -307,8 +308,8 @@ test( "range", function( assert ) {
step: 1
} );
- equal( element.find( ".ui-slider-handle" ).length, 1, "range max, one handle" );
- equal( element.find( ".ui-slider-range-max" ).length, 1, "range max" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 1, "range max, one handle" );
+ assert.equal( element.find( ".ui-slider-range-max" ).length, 1, "range max" );
element.slider( "destroy" );
// True
@@ -320,7 +321,7 @@ test( "range", function( assert ) {
} );
range = element.find( ".ui-slider-range" );
- equal( element.find( ".ui-slider-handle" ).length, 2, "range true, two handles" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 2, "range true, two handles" );
assert.lacksClasses( range, "ui-slider-range-max ui-slider-range-min" );
element.slider( "destroy" );
@@ -332,9 +333,9 @@ test( "range", function( assert ) {
step: 1
} ).slider( "option", "range", "max" );
- equal( element.find( ".ui-slider-handle" ).length, 1, "range switch from min to max, one handle" );
- equal( element.find( ".ui-slider-range-min" ).length, 0, "range switch from min to max" );
- equal( element.find( ".ui-slider-range-max" ).length, 1, "range switch from min to max" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 1, "range switch from min to max, one handle" );
+ assert.equal( element.find( ".ui-slider-range-min" ).length, 0, "range switch from min to max" );
+ assert.equal( element.find( ".ui-slider-range-max" ).length, 1, "range switch from min to max" );
element.slider( "destroy" );
// Change range from max to min
@@ -345,9 +346,9 @@ test( "range", function( assert ) {
step: 1
} ).slider( "option", "range", "min" );
- equal( element.find( ".ui-slider-handle" ).length, 1, "range switch from max to min, one handle" );
- equal( element.find( ".ui-slider-range-max" ).length, 0, "range switch from max to min" );
- equal( element.find( ".ui-slider-range-min" ).length, 1, "range switch from max to min" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 1, "range switch from max to min, one handle" );
+ assert.equal( element.find( ".ui-slider-range-max" ).length, 0, "range switch from max to min" );
+ assert.equal( element.find( ".ui-slider-range-min" ).length, 1, "range switch from max to min" );
element.slider( "destroy" );
// Change range from max to true
@@ -358,13 +359,13 @@ test( "range", function( assert ) {
step: 1
} ).slider( "option", "range", true );
- equal( element.find( ".ui-slider-handle" ).length, 2, "range switch from max to true, two handles" );
- equal( element.find( ".ui-slider-range-max" ).length, 0, "range switch from max to true" );
- equal( element.find( ".ui-slider-range-min" ).length, 0, "range switch from max to true" );
- equal( element.slider( "option", "value" ), 0, "option value" );
- equal( element.slider( "value" ), 1, "value" );
- deepEqual( element.slider( "option", "values" ), [ 1, 1 ], "option values" );
- deepEqual( element.slider( "values" ), [ 1, 1 ], "values" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 2, "range switch from max to true, two handles" );
+ assert.equal( element.find( ".ui-slider-range-max" ).length, 0, "range switch from max to true" );
+ assert.equal( element.find( ".ui-slider-range-min" ).length, 0, "range switch from max to true" );
+ assert.equal( element.slider( "option", "value" ), 0, "option value" );
+ assert.equal( element.slider( "value" ), 1, "value" );
+ assert.deepEqual( element.slider( "option", "values" ), [ 1, 1 ], "option values" );
+ assert.deepEqual( element.slider( "values" ), [ 1, 1 ], "values" );
element.slider( "destroy" );
// Change range from true to min
@@ -375,13 +376,13 @@ test( "range", function( assert ) {
step: 1
} ).slider( "option", "range", "min" );
- equal( element.find( ".ui-slider-handle" ).length, 1, "range switch from true to min, one handle" );
- equal( element.find( ".ui-slider-range-max" ).length, 0, "range switch from true to min" );
- equal( element.find( ".ui-slider-range-min" ).length, 1, "range switch from true to min" );
- equal( element.slider( "option", "value" ), 1, "value" );
- equal( element.slider( "value" ), 1, "value" );
- equal( element.slider( "option", "values" ), null, "values" );
- deepEqual( element.slider( "values" ), [], "values" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 1, "range switch from true to min, one handle" );
+ assert.equal( element.find( ".ui-slider-range-max" ).length, 0, "range switch from true to min" );
+ assert.equal( element.find( ".ui-slider-range-min" ).length, 1, "range switch from true to min" );
+ assert.equal( element.slider( "option", "value" ), 1, "value" );
+ assert.equal( element.slider( "value" ), 1, "value" );
+ assert.equal( element.slider( "option", "values" ), null, "values" );
+ assert.deepEqual( element.slider( "values" ), [], "values" );
element.slider( "destroy" );
// Change range from true to false
@@ -391,12 +392,12 @@ test( "range", function( assert ) {
max: 10,
step: 1
} ).slider( "option", "range", false );
- equal( element.find( ".ui-slider-handle" ).length, 2, "range switch from true to false, both handles remain" );
- equal( element.find( ".ui-slider-range" ).length, 0, "range switch from true to false" );
- equal( element.slider( "option", "value" ), 0, "option value" );
- equal( element.slider( "value" ), 1, "value" );
- deepEqual( element.slider( "option", "values" ), [ 1, 1 ], "option values" );
- deepEqual( element.slider( "values" ), [ 1, 1 ], "values" );
+ assert.equal( element.find( ".ui-slider-handle" ).length, 2, "range switch from true to false, both handles remain" );
+ assert.equal( element.find( ".ui-slider-range" ).length, 0, "range switch from true to false" );
+ assert.equal( element.slider( "option", "value" ), 0, "option value" );
+ assert.equal( element.slider( "value" ), 1, "value" );
+ assert.deepEqual( element.slider( "option", "values" ), [ 1, 1 ], "option values" );
+ assert.deepEqual( element.slider( "values" ), [ 1, 1 ], "values" );
element.slider( "destroy" );
} );
From 749f95ee0ab25b7ee03b3def88ec5bc604ab9929 Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Wed, 6 Apr 2016 18:52:59 +0530
Subject: [PATCH 20/26] Sortable: Shift to use no globals
---
tests/unit/sortable/core.js | 17 +--
tests/unit/sortable/events.js | 211 +++++++++++++++++----------------
tests/unit/sortable/helper.js | 4 +-
tests/unit/sortable/methods.js | 69 +++++------
tests/unit/sortable/options.js | 102 ++++++++--------
5 files changed, 204 insertions(+), 199 deletions(-)
diff --git a/tests/unit/sortable/core.js b/tests/unit/sortable/core.js
index d12416f0903..2bb11edbe2c 100644
--- a/tests/unit/sortable/core.js
+++ b/tests/unit/sortable/core.js
@@ -1,23 +1,24 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/sortable"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
-module( "sortable: core" );
+QUnit.module( "sortable: core" );
-test( "#9314: Sortable: Items cannot be dragged directly into bottom position", function() {
- expect( 1 );
+QUnit.test( "#9314: Sortable: Items cannot be dragged directly into bottom position", function( assert ) {
+ assert.expect( 1 );
var el = $( ".connectWith" ).sortable( {
connectWith: ".connectWith"
} );
- testHelper.sort( $( "li", el[ 1 ] )[ 0 ], 0, -12, 5, "Dragging the sortable into connected sortable" );
+ testHelper.sort( assert, $( "li", el[ 1 ] )[ 0 ], 0, -12, 5, "Dragging the sortable into connected sortable" );
} );
-test( "ui-sortable-handle applied to appropriate element", function( assert ) {
- expect( 8 );
+QUnit.test( "ui-sortable-handle applied to appropriate element", function( assert ) {
+ assert.expect( 8 );
var item = "",
el = $( "" )
.sortable()
@@ -36,7 +37,7 @@ test( "ui-sortable-handle applied to appropriate element", function( assert ) {
assert.hasClasses( el.find( "p:last" ), "ui-sortable-handle" );
el.sortable( "destroy" );
- equal( el.find( ".ui-sortable-handle" ).length, 0, "class name removed on destroy" );
+ assert.equal( el.find( ".ui-sortable-handle" ).length, 0, "class name removed on destroy" );
} );
} );
diff --git a/tests/unit/sortable/events.js b/tests/unit/sortable/events.js
index d2416fbc4ca..4973abef0bd 100644
--- a/tests/unit/sortable/events.js
+++ b/tests/unit/sortable/events.js
@@ -1,14 +1,15 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/sortable",
"ui/widgets/draggable"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
-module( "sortable: events" );
+QUnit.module( "sortable: events" );
-test( "start", function() {
- expect( 7 );
+QUnit.test( "start", function( assert ) {
+ assert.expect( 7 );
var hash;
$( "#sortable" ).sortable( {
@@ -19,19 +20,19 @@ test( "start", function() {
dy: 10
} );
- ok( hash, "start event triggered" );
- ok( hash.helper, "UI hash includes: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.item, "UI hash includes: item" );
- ok( !hash.sender, "UI hash does not include: sender" );
+ assert.ok( hash, "start event triggered" );
+ assert.ok( hash.helper, "UI hash includes: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( !hash.sender, "UI hash does not include: sender" );
// Todo: see if these events should actually have sane values in them
- ok( "position" in hash, "UI hash includes: position" );
- ok( "offset" in hash, "UI hash includes: offset" );
+ assert.ok( "position" in hash, "UI hash includes: position" );
+ assert.ok( "offset" in hash, "UI hash includes: offset" );
} );
-test( "sort", function() {
- expect( 7 );
+QUnit.test( "sort", function( assert ) {
+ assert.expect( 7 );
var hash;
$( "#sortable" ).sortable( {
@@ -42,18 +43,18 @@ test( "sort", function() {
dy: 10
} );
- ok( hash, "sort event triggered" );
- ok( hash.helper, "UI hash includes: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
- ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
- ok( hash.item, "UI hash includes: item" );
- ok( !hash.sender, "UI hash does not include: sender" );
+ assert.ok( hash, "sort event triggered" );
+ assert.ok( hash.helper, "UI hash includes: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
+ assert.ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( !hash.sender, "UI hash does not include: sender" );
} );
-test( "change", function() {
- expect( 8 );
+QUnit.test( "change", function( assert ) {
+ assert.expect( 8 );
var hash;
$( "#sortable" ).sortable( {
@@ -65,7 +66,7 @@ test( "change", function() {
dy: 1
} );
- ok( !hash, "1px drag, change event should not be triggered" );
+ assert.ok( !hash, "1px drag, change event should not be triggered" );
$( "#sortable" ).sortable( {
change: function( e, ui ) {
@@ -75,18 +76,18 @@ test( "change", function() {
dy: 22
} );
- ok( hash, "change event triggered" );
- ok( hash.helper, "UI hash includes: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
- ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
- ok( hash.item, "UI hash includes: item" );
- ok( !hash.sender, "UI hash does not include: sender" );
+ assert.ok( hash, "change event triggered" );
+ assert.ok( hash.helper, "UI hash includes: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
+ assert.ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( !hash.sender, "UI hash does not include: sender" );
} );
-test( "beforeStop", function() {
- expect( 7 );
+QUnit.test( "beforeStop", function( assert ) {
+ assert.expect( 7 );
var hash;
$( "#sortable" ).sortable( {
@@ -97,18 +98,18 @@ test( "beforeStop", function() {
dy: 20
} );
- ok( hash, "beforeStop event triggered" );
- ok( hash.helper, "UI hash includes: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
- ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
- ok( hash.item, "UI hash includes: item" );
- ok( !hash.sender, "UI hash does not include: sender" );
+ assert.ok( hash, "beforeStop event triggered" );
+ assert.ok( hash.helper, "UI hash includes: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
+ assert.ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( !hash.sender, "UI hash does not include: sender" );
} );
-test( "stop", function() {
- expect( 7 );
+QUnit.test( "stop", function( assert ) {
+ assert.expect( 7 );
var hash;
$( "#sortable" ).sortable( {
@@ -119,18 +120,18 @@ test( "stop", function() {
dy: 20
} );
- ok( hash, "stop event triggered" );
- ok( !hash.helper, "UI should not include: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
- ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
- ok( hash.item, "UI hash includes: item" );
- ok( !hash.sender, "UI hash does not include: sender" );
+ assert.ok( hash, "stop event triggered" );
+ assert.ok( !hash.helper, "UI should not include: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
+ assert.ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( !hash.sender, "UI hash does not include: sender" );
} );
-test( "update", function() {
- expect( 8 );
+QUnit.test( "update", function( assert ) {
+ assert.expect( 8 );
var hash;
$( "#sortable" ).sortable( {
@@ -142,7 +143,7 @@ test( "update", function() {
dy: 1
} );
- ok( !hash, "1px drag, update event should not be triggered" );
+ assert.ok( !hash, "1px drag, update event should not be triggered" );
$( "#sortable" ).sortable( {
update: function( e, ui ) {
@@ -152,18 +153,18 @@ test( "update", function() {
dy: 22
} );
- ok( hash, "update event triggered" );
- ok( !hash.helper, "UI hash should not include: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
- ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
- ok( hash.item, "UI hash includes: item" );
- ok( !hash.sender, "UI hash does not include: sender" );
+ assert.ok( hash, "update event triggered" );
+ assert.ok( !hash.helper, "UI hash should not include: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
+ assert.ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( !hash.sender, "UI hash does not include: sender" );
} );
-test( "#3019: Stop fires too early", function() {
- expect( 2 );
+QUnit.test( "#3019: Stop fires too early", function( assert ) {
+ assert.expect( 2 );
var helper = null,
el = $( "#sortable" ).sortable( {
@@ -172,13 +173,13 @@ test( "#3019: Stop fires too early", function() {
}
} );
- testHelper.sort( $( "li", el )[ 0 ], 0, 44, 2, "Dragging the sortable" );
- equal( helper, null, "helper should be false" );
+ testHelper.sort( assert, $( "li", el )[ 0 ], 0, 44, 2, "Dragging the sortable" );
+ assert.equal( helper, null, "helper should be false" );
} );
-test( "#4752: link event firing on sortable with connect list", function() {
- expect( 10 );
+QUnit.test( "#4752: link event firing on sortable with connect list", function( assert ) {
+ assert.expect( 10 );
var fired = {},
hasFired = function( type ) { return ( type in fired ) && ( true === fired[ type ] ); };
@@ -203,28 +204,28 @@ test( "#4752: link event firing on sortable with connect list", function() {
} );
$( "#sortable li:eq(0)" ).simulate( "click" );
- ok( !hasFired( "change" ), "Click only, change event should not have fired" );
- ok( hasFired( "click" ), "Click event should have fired" );
+ assert.ok( !hasFired( "change" ), "Click only, change event should not have fired" );
+ assert.ok( hasFired( "click" ), "Click event should have fired" );
// Drag an item within the first list
fired = {};
$( "#sortable li:eq(0)" ).simulate( "drag", { dx: 0, dy: 40 } );
- ok( hasFired( "change" ), "40px drag, change event should have fired" );
- ok( !hasFired( "receive" ), "Receive event should not have fired" );
- ok( !hasFired( "remove" ), "Remove event should not have fired" );
- ok( !hasFired( "click" ), "Click event should not have fired" );
+ assert.ok( hasFired( "change" ), "40px drag, change event should have fired" );
+ assert.ok( !hasFired( "receive" ), "Receive event should not have fired" );
+ assert.ok( !hasFired( "remove" ), "Remove event should not have fired" );
+ assert.ok( !hasFired( "click" ), "Click event should not have fired" );
// Drag an item from the first list to the second, connected list
fired = {};
$( "#sortable li:eq(0)" ).simulate( "drag", { dx: 0, dy: 150 } );
- ok( hasFired( "change" ), "150px drag, change event should have fired" );
- ok( hasFired( "receive" ), "Receive event should have fired" );
- ok( hasFired( "remove" ), "Remove event should have fired" );
- ok( !hasFired( "click" ), "Click event should not have fired" );
+ assert.ok( hasFired( "change" ), "150px drag, change event should have fired" );
+ assert.ok( hasFired( "receive" ), "Receive event should have fired" );
+ assert.ok( hasFired( "remove" ), "Remove event should have fired" );
+ assert.ok( !hasFired( "click" ), "Click event should not have fired" );
} );
/*
-test("receive", function() {
+Test("receive", function() {
ok(false, "missing test - untested code is broken code.");
});
@@ -233,8 +234,8 @@ test("remove", function() {
});
*/
-test( "over", function() {
- expect( 8 );
+QUnit.test( "over", function( assert ) {
+ assert.expect( 8 );
var hash,
overCount = 0;
@@ -248,20 +249,20 @@ test( "over", function() {
dy: 20
} );
- ok( hash, "over event triggered" );
- ok( hash.helper, "UI includes: helper" );
- ok( hash.placeholder, "UI hash includes: placeholder" );
- ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
- ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
- ok( hash.item, "UI hash includes: item" );
- ok( hash.sender, "UI hash includes: sender" );
- equal( overCount, 1, "over fires only once" );
+ assert.ok( hash, "over event triggered" );
+ assert.ok( hash.helper, "UI includes: helper" );
+ assert.ok( hash.placeholder, "UI hash includes: placeholder" );
+ assert.ok( hash.position && ( "top" in hash.position && "left" in hash.position ), "UI hash includes: position" );
+ assert.ok( hash.offset && ( hash.offset.top && hash.offset.left ), "UI hash includes: offset" );
+ assert.ok( hash.item, "UI hash includes: item" );
+ assert.ok( hash.sender, "UI hash includes: sender" );
+ assert.equal( overCount, 1, "over fires only once" );
} );
// http://bugs.jqueryui.com/ticket/9335
// Sortable: over & out events does not consistently fire
-test( "over, fires with draggable connected to sortable", function() {
- expect( 3 );
+QUnit.test( "over, fires with draggable connected to sortable", function( assert ) {
+ assert.expect( 3 );
var hash,
overCount = 0,
@@ -282,13 +283,13 @@ test( "over, fires with draggable connected to sortable", function() {
dy: -20
} );
- ok( hash, "over event triggered" );
- ok( !hash.sender, "UI should not include: sender" );
- equal( overCount, 1, "over fires only once" );
+ assert.ok( hash, "over event triggered" );
+ assert.ok( !hash.sender, "UI should not include: sender" );
+ assert.equal( overCount, 1, "over fires only once" );
} );
-test( "over, with connected sortable", function() {
- expect( 3 );
+QUnit.test( "over, with connected sortable", function( assert ) {
+ assert.expect( 3 );
var hash,
overCount = 0;
@@ -304,19 +305,19 @@ test( "over, with connected sortable", function() {
dy: 102
} );
- ok( hash, "over event triggered" );
- equal( hash.sender[ 0 ], $( " #sortable" )[ 0 ], "UI includes: sender" );
- equal( overCount, 1, "over fires only once" );
+ assert.ok( hash, "over event triggered" );
+ assert.equal( hash.sender[ 0 ], $( " #sortable" )[ 0 ], "UI includes: sender" );
+ assert.equal( overCount, 1, "over fires only once" );
} );
/*
-test("out", function() {
+Test("out", function() {
ok(false, "missing test - untested code is broken code.");
});
*/
-test( "out, with connected sortable", function() {
- expect( 2 );
+QUnit.test( "out, with connected sortable", function( assert ) {
+ assert.expect( 2 );
var hash,
outCount = 0;
@@ -332,12 +333,12 @@ test( "out, with connected sortable", function() {
dy: 40
} );
- ok( hash, "out event triggered" );
- equal( outCount, 1, "out fires only once" );
+ assert.ok( hash, "out event triggered" );
+ assert.equal( outCount, 1, "out fires only once" );
} );
-test( "repeated out & over between connected sortables", function() {
- expect( 2 );
+QUnit.test( "repeated out & over between connected sortables", function( assert ) {
+ assert.expect( 2 );
var outCount = 0,
overCount = 0;
@@ -362,12 +363,12 @@ test( "repeated out & over between connected sortables", function() {
dy: -40
} );
- equal( outCount, 2, "out fires twice" );
- equal( overCount, 4, "over fires four times" );
+ assert.equal( outCount, 2, "out fires twice" );
+ assert.equal( overCount, 4, "over fires four times" );
} );
/*
-test("activate", function() {
+Test("activate", function() {
ok(false, "missing test - untested code is broken code.");
});
diff --git a/tests/unit/sortable/helper.js b/tests/unit/sortable/helper.js
index c1c0b6e74f8..61de63ae97c 100644
--- a/tests/unit/sortable/helper.js
+++ b/tests/unit/sortable/helper.js
@@ -4,12 +4,12 @@ define( [
], function( $, helper ) {
return $.extend( helper, {
- sort: function( handle, dx, dy, index, msg ) {
+ sort: function( assert, handle, dx, dy, index, msg ) {
$( handle ).simulate( "drag", {
dx: dx,
dy: dy
} );
- equal( $( handle ).parent().children().index( handle ), index, msg );
+ assert.equal( $( handle ).parent().children().index( handle ), index, msg );
}
} );
diff --git a/tests/unit/sortable/methods.js b/tests/unit/sortable/methods.js
index 1d2fda8ff35..b52d641ed25 100644
--- a/tests/unit/sortable/methods.js
+++ b/tests/unit/sortable/methods.js
@@ -1,98 +1,99 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/sortable"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
-module( "sortable: methods" );
+QUnit.module( "sortable: methods" );
-test( "init", function() {
- expect( 5 );
+QUnit.test( "init", function( assert ) {
+ assert.expect( 5 );
$( "" ).appendTo( "body" ).sortable().remove();
- ok( true, ".sortable() called on element" );
+ assert.ok( true, ".sortable() called on element" );
$( [] ).sortable();
- ok( true, ".sortable() called on empty collection" );
+ assert.ok( true, ".sortable() called on empty collection" );
$( "" ).sortable();
- ok( true, ".sortable() called on disconnected DOMElement" );
+ assert.ok( true, ".sortable() called on disconnected DOMElement" );
$( "" ).sortable().sortable( "option", "foo" );
- ok( true, "arbitrary option getter after init" );
+ assert.ok( true, "arbitrary option getter after init" );
$( "" ).sortable().sortable( "option", "foo", "bar" );
- ok( true, "arbitrary option setter after init" );
+ assert.ok( true, "arbitrary option setter after init" );
} );
-test( "destroy", function() {
- expect( 4 );
+QUnit.test( "destroy", function( assert ) {
+ assert.expect( 4 );
$( "" ).appendTo( "body" ).sortable().sortable( "destroy" ).remove();
- ok( true, ".sortable('destroy') called on element" );
+ assert.ok( true, ".sortable('destroy') called on element" );
$( [] ).sortable().sortable( "destroy" );
- ok( true, ".sortable('destroy') called on empty collection" );
+ assert.ok( true, ".sortable('destroy') called on empty collection" );
$( "" ).sortable().sortable( "destroy" );
- ok( true, ".sortable('destroy') called on disconnected DOMElement" );
+ assert.ok( true, ".sortable('destroy') called on disconnected DOMElement" );
var expected = $( "" ).sortable(),
actual = expected.sortable( "destroy" );
- equal( actual, expected, "destroy is chainable" );
+ assert.equal( actual, expected, "destroy is chainable" );
} );
-test( "enable", function() {
- expect( 5 );
+QUnit.test( "enable", function( assert ) {
+ assert.expect( 5 );
var el, actual, expected;
el = $( "#sortable" ).sortable( { disabled: true } );
- testHelper.sort( $( "li", el )[ 0 ], 0, 44, 0, ".sortable({ disabled: true })" );
+ testHelper.sort( assert, $( "li", el )[ 0 ], 0, 44, 0, ".sortable({ disabled: true })" );
el.sortable( "enable" );
- equal( el.sortable( "option", "disabled" ), false, "disabled option getter" );
+ assert.equal( el.sortable( "option", "disabled" ), false, "disabled option getter" );
el.sortable( "destroy" );
el.sortable( { disabled: true } );
el.sortable( "option", "disabled", false );
- equal( el.sortable( "option", "disabled" ), false, "disabled option setter" );
+ assert.equal( el.sortable( "option", "disabled" ), false, "disabled option setter" );
- testHelper.sort( $( "li", el )[ 0 ], 0, 44, 2, ".sortable('option', 'disabled', false)" );
+ testHelper.sort( assert, $( "li", el )[ 0 ], 0, 44, 2, ".sortable('option', 'disabled', false)" );
expected = $( "" ).sortable(),
actual = expected.sortable( "enable" );
- equal( actual, expected, "enable is chainable" );
+ assert.equal( actual, expected, "enable is chainable" );
} );
-test( "disable", function( assert ) {
- expect( 9 );
+QUnit.test( "disable", function( assert ) {
+ assert.expect( 9 );
var chainable,
element = $( "#sortable" ).sortable( { disabled: false } );
- testHelper.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" );
+ testHelper.sort( assert, $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" );
chainable = element.sortable( "disable" );
- testHelper.sort( $( "li", element )[ 0 ], 0, 44, 0, "disabled.sortable getter" );
+ testHelper.sort( assert, $( "li", element )[ 0 ], 0, 44, 0, "disabled.sortable getter" );
element.sortable( "destroy" );
element.sortable( { disabled: false } );
- testHelper.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" );
+ testHelper.sort( assert, $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" );
element.sortable( "option", "disabled", true );
- equal( element.sortable( "option", "disabled" ), true, "disabled option setter" );
+ assert.equal( element.sortable( "option", "disabled" ), true, "disabled option setter" );
assert.lacksClasses( element.sortable( "widget" ), "ui-state-disabled" );
- ok( !element.sortable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" );
+ assert.ok( !element.sortable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" );
assert.hasClasses( element.sortable( "widget" ), "ui-sortable-disabled" );
- testHelper.sort( $( "li", element )[ 0 ], 0, 44, 0, ".sortable('option', 'disabled', true)" );
- equal( chainable, element, "disable is chainable" );
+ testHelper.sort( assert, $( "li", element )[ 0 ], 0, 44, 0, ".sortable('option', 'disabled', true)" );
+ assert.equal( chainable, element, "disable is chainable" );
} );
-test( "refresh() should update the positions of initially empty lists (see #7498)", function() {
- expect( 1 );
+QUnit.test( "refresh() should update the positions of initially empty lists (see #7498)", function( assert ) {
+ assert.expect( 1 );
var changeCount = 0,
element = $( "#qunit-fixture" ).html( "" ).find( "ul" );
@@ -123,7 +124,7 @@ test( "refresh() should update the positions of initially empty lists (see #7498
moves: 15
} );
- equal( changeCount, 1 );
+ assert.equal( changeCount, 1 );
} );
} );
diff --git a/tests/unit/sortable/options.js b/tests/unit/sortable/options.js
index ba3a70d99d2..fa0c487b720 100644
--- a/tests/unit/sortable/options.js
+++ b/tests/unit/sortable/options.js
@@ -1,12 +1,13 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/sortable"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "sortable: options" );
+QUnit.module( "sortable: options" );
/*
-test("{ appendTo: 'parent' }, default", function() {
+Test("{ appendTo: 'parent' }, default", function() {
ok(false, "missing test - untested code is broken code.");
});
@@ -15,16 +16,16 @@ test("{ appendTo: Selector }", function() {
});
*/
-test( "{ axis: false }, default", function() {
- expect( 2 );
+QUnit.test( "{ axis: false }, default", function( assert ) {
+ assert.expect( 2 );
var offsetAfter,
element = $( "#sortable" ).sortable( {
axis: false,
change: function() {
offsetAfter = item.offset();
- notEqual( offsetAfter.left, offsetBefore.left, "x axis not constrained when axis: false" );
- notEqual( offsetAfter.top, offsetBefore.top, "y axis not constrained when axis: false" );
+ assert.notEqual( offsetAfter.left, offsetBefore.left, "x axis not constrained when axis: false" );
+ assert.notEqual( offsetAfter.top, offsetBefore.top, "y axis not constrained when axis: false" );
}
} ),
item = element.find( "li" ).eq( 0 ),
@@ -37,16 +38,16 @@ test( "{ axis: false }, default", function() {
} );
} );
-test( "{ axis: 'x' }", function() {
- expect( 2 );
+QUnit.test( "{ axis: 'x' }", function( assert ) {
+ assert.expect( 2 );
var offsetAfter,
element = $( "#sortable" ).sortable( {
axis: "x",
change: function() {
offsetAfter = item.offset();
- notEqual( offsetAfter.left, offsetBefore.left, "x axis not constrained when axis: x" );
- equal( offsetAfter.top, offsetBefore.top, "y axis constrained when axis: x" );
+ assert.notEqual( offsetAfter.left, offsetBefore.left, "x axis not constrained when axis: x" );
+ assert.equal( offsetAfter.top, offsetBefore.top, "y axis constrained when axis: x" );
}
} ),
item = element.find( "li" ).eq( 0 ),
@@ -59,16 +60,16 @@ test( "{ axis: 'x' }", function() {
} );
} );
-test( "{ axis: 'y' }", function() {
- expect( 2 );
+QUnit.test( "{ axis: 'y' }", function( assert ) {
+ assert.expect( 2 );
var offsetAfter,
element = $( "#sortable" ).sortable( {
axis: "y",
change: function() {
offsetAfter = item.offset();
- equal( offsetAfter.left, offsetBefore.left, "x axis constrained when axis: y" );
- notEqual( offsetAfter.top, offsetBefore.top, "y axis not constrained when axis: y" );
+ assert.equal( offsetAfter.left, offsetBefore.left, "x axis constrained when axis: y" );
+ assert.notEqual( offsetAfter.top, offsetBefore.top, "y axis not constrained when axis: y" );
}
} ),
item = element.find( "li" ).eq( 0 ),
@@ -81,8 +82,9 @@ test( "{ axis: 'y' }", function() {
} );
} );
-asyncTest( "#7415: Incorrect revert animation with axis: 'y'", function() {
- expect( 2 );
+QUnit.test( "#7415: Incorrect revert animation with axis: 'y'", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 2 );
var expectedLeft,
element = $( "#sortable" ).sortable( {
axis: "y",
@@ -100,14 +102,14 @@ asyncTest( "#7415: Incorrect revert animation with axis: 'y'", function() {
setTimeout( function() {
var top = parseFloat( item.css( "top" ) );
- equal( item.css( "left" ), expectedLeft, "left not animated" );
- ok( top > 0 && top < 300, "top is animated" );
- start();
+ assert.equal( item.css( "left" ), expectedLeft, "left not animated" );
+ assert.ok( top > 0 && top < 300, "top is animated" );
+ ready();
}, 100 );
} );
/*
-test("{ cancel: 'input,textarea,button,select,option' }, default", function() {
+Test("{ cancel: 'input,textarea,button,select,option' }, default", function() {
ok(false, "missing test - untested code is broken code.");
});
@@ -116,8 +118,8 @@ test("{ cancel: Selector }", function() {
});
*/
-test( "#8792: issues with floated items in connected lists", function() {
- expect( 2 );
+QUnit.test( "#8792: issues with floated items in connected lists", function( assert ) {
+ assert.expect( 2 );
var element,
changeCount = 0;
@@ -142,7 +144,7 @@ test( "#8792: issues with floated items in connected lists", function() {
moves: 15
} );
- equal( changeCount, 1, "change fired only once (no jitters) when dragging a floated sortable in it's own container" );
+ assert.equal( changeCount, 1, "change fired only once (no jitters) when dragging a floated sortable in it's own container" );
// Move the first li ( which is now in the second spot )
// through the first spot in the second ul to the second spot in the second ul
@@ -151,11 +153,11 @@ test( "#8792: issues with floated items in connected lists", function() {
moves: 15
} );
- equal( changeCount, 3, "change fired once for each expected change when dragging a floated sortable to a connected container" );
+ assert.equal( changeCount, 3, "change fired once for each expected change when dragging a floated sortable to a connected container" );
} );
-test( "#8301: single axis with connected list", function() {
- expect( 1 );
+QUnit.test( "#8301: single axis with connected list", function( assert ) {
+ assert.expect( 1 );
var element = $( "#sortable" ).sortable( {
axis: "y",
@@ -169,7 +171,7 @@ test( "#8301: single axis with connected list", function() {
tolerance: "pointer",
connectWith: "#sortable",
receive: function() {
- ok( true, "connected list received item" );
+ assert.ok( true, "connected list received item" );
}
} )
.insertAfter( element );
@@ -182,7 +184,7 @@ test( "#8301: single axis with connected list", function() {
} );
/*
-test("{ connectWith: false }, default", function() {
+Test("{ connectWith: false }, default", function() {
ok(false, "missing test - untested code is broken code.");
});
@@ -327,14 +329,14 @@ test("{ placeholder: false }, default", function() {
});
*/
-test( "{ placeholder: false } img", function() {
- expect( 3 );
+QUnit.test( "{ placeholder: false } img", function( assert ) {
+ assert.expect( 3 );
var element = $( "#sortable-images" ).sortable( {
start: function( event, ui ) {
- ok( ui.placeholder.attr( "src" ).indexOf( "images/jqueryui_32x32.png" ) > 0, "placeholder img has correct src" );
- equal( ui.placeholder.height(), 32, "placeholder has correct height" );
- equal( ui.placeholder.width(), 32, "placeholder has correct width" );
+ assert.ok( ui.placeholder.attr( "src" ).indexOf( "images/jqueryui_32x32.png" ) > 0, "placeholder img has correct src" );
+ assert.equal( ui.placeholder.height(), 32, "placeholder has correct height" );
+ assert.equal( ui.placeholder.width(), 32, "placeholder has correct width" );
}
} );
@@ -343,8 +345,8 @@ test( "{ placeholder: false } img", function() {
} );
} );
-test( "{ placeholder: String }", function( assert ) {
- expect( 1 );
+QUnit.test( "{ placeholder: String }", function( assert ) {
+ assert.expect( 1 );
var element = $( "#sortable" ).sortable( {
placeholder: "test",
@@ -358,8 +360,8 @@ test( "{ placeholder: String }", function( assert ) {
} );
} );
-test( "{ placholder: String } tr", function( assert ) {
- expect( 4 );
+QUnit.test( "{ placholder: String } tr", function( assert ) {
+ assert.expect( 4 );
var originalWidths,
element = $( "#sortable-table tbody" ).sortable( {
@@ -369,10 +371,10 @@ test( "{ placholder: String } tr", function( assert ) {
return $( this ).width();
} ).get();
assert.hasClasses( ui.placeholder, "test" );
- deepEqual( currentWidths, originalWidths, "table cells maintian size" );
- equal( ui.placeholder.children().length, dragRow.children().length,
+ assert.deepEqual( currentWidths, originalWidths, "table cells maintian size" );
+ assert.equal( ui.placeholder.children().length, dragRow.children().length,
"placeholder has correct number of cells" );
- equal( ui.placeholder.children().html(), $( " " ).html(),
+ assert.equal( ui.placeholder.children().html(), $( " " ).html(),
"placeholder td has content for forced dimensions" );
}
} ),
@@ -388,8 +390,8 @@ test( "{ placholder: String } tr", function( assert ) {
} );
} );
-test( "{ placholder: String } tbody", function() {
- expect( 6 );
+QUnit.test( "{ placholder: String } tbody", function( assert ) {
+ assert.expect( 6 );
var originalWidths,
element = $( "#sortable-table" ).sortable( {
@@ -398,16 +400,16 @@ test( "{ placholder: String } tbody", function() {
var currentWidths = otherBody.children().map( function() {
return $( this ).width();
} ).get();
- ok( ui.placeholder.hasClass( "test" ), "placeholder has class" );
- deepEqual( currentWidths, originalWidths, "table cells maintain size" );
- equal( ui.placeholder.children().length, 1,
+ assert.ok( ui.placeholder.hasClass( "test" ), "placeholder has class" );
+ assert.deepEqual( currentWidths, originalWidths, "table cells maintain size" );
+ assert.equal( ui.placeholder.children().length, 1,
"placeholder has one child" );
- equal( ui.placeholder.children( "tr" ).length, 1,
+ assert.equal( ui.placeholder.children( "tr" ).length, 1,
"placeholder's child is tr" );
- equal( ui.placeholder.find( "> tr" ).children().length,
+ assert.equal( ui.placeholder.find( "> tr" ).children().length,
dragBody.find( "> tr:first" ).children().length,
"placeholder's tr has correct number of cells" );
- equal( ui.placeholder.find( "> tr" ).children().html(),
+ assert.equal( ui.placeholder.find( "> tr" ).children().html(),
$( " " ).html(),
"placeholder td has content for forced dimensions" );
}
@@ -425,7 +427,7 @@ test( "{ placholder: String } tbody", function() {
} );
/*
-test("{ revert: false }, default", function() {
+Test("{ revert: false }, default", function() {
ok(false, "missing test - untested code is broken code.");
});
From b5028f02bf29a882e5a1c35bf58220f69ea5a998 Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Wed, 6 Apr 2016 18:56:05 +0530
Subject: [PATCH 21/26] Spinner: Shift to use no globals
---
tests/unit/spinner/core.js | 174 ++++++++++++++++---------------
tests/unit/spinner/deprecated.js | 13 +--
tests/unit/spinner/events.js | 32 +++---
tests/unit/spinner/methods.js | 133 +++++++++++------------
tests/unit/spinner/options.js | 155 +++++++++++++--------------
5 files changed, 257 insertions(+), 250 deletions(-)
diff --git a/tests/unit/spinner/core.js b/tests/unit/spinner/core.js
index 23df35da475..6d817134ae1 100644
--- a/tests/unit/spinner/core.js
+++ b/tests/unit/spinner/core.js
@@ -1,15 +1,16 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/spinner"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
var simulateKeyDownUp = testHelper.simulateKeyDownUp;
-module( "spinner: core" );
+QUnit.module( "spinner: core" );
-test( "markup structure", function( assert ) {
- expect( 6 );
+QUnit.test( "markup structure", function( assert ) {
+ assert.expect( 6 );
var element = $( "#spin" ).spinner(),
spinner = element.spinner( "widget" ),
up = spinner.find( ".ui-spinner-up" ),
@@ -18,101 +19,102 @@ test( "markup structure", function( assert ) {
assert.hasClasses( element, "ui-spinner-input" );
assert.hasClasses( spinner, "ui-spinner ui-widget ui-widget-content" );
assert.hasClasses( up, "ui-spinner-button ui-spinner-up ui-widget" );
- equal( up.length, 1, "Spinner contains exactly one up button" );
+ assert.equal( up.length, 1, "Spinner contains exactly one up button" );
assert.hasClasses( down, "ui-spinner-button ui-spinner-down ui-widget" );
- equal( down.length, 1, "Spinner contains exactly one down button" );
+ assert.equal( down.length, 1, "Spinner contains exactly one down button" );
} );
-test( "keydown UP on input, increases value not greater than max", function() {
- expect( 5 );
+QUnit.test( "keydown UP on input, increases value not greater than max", function( assert ) {
+ assert.expect( 5 );
var element = $( "#spin" ).val( 70 ).spinner( {
max: 100,
step: 10
} );
simulateKeyDownUp( element, $.ui.keyCode.UP );
- equal( element.val(), 80 );
+ assert.equal( element.val(), 80 );
simulateKeyDownUp( element, $.ui.keyCode.UP );
- equal( element.val(), 90 );
+ assert.equal( element.val(), 90 );
simulateKeyDownUp( element, $.ui.keyCode.UP );
- equal( element.val(), 100 );
+ assert.equal( element.val(), 100 );
simulateKeyDownUp( element, $.ui.keyCode.UP );
- equal( element.val(), 100 );
+ assert.equal( element.val(), 100 );
simulateKeyDownUp( element, $.ui.keyCode.UP );
- equal( element.val(), 100 );
+ assert.equal( element.val(), 100 );
} );
-test( "keydown DOWN on input, decreases value not less than min", function() {
- expect( 5 );
+QUnit.test( "keydown DOWN on input, decreases value not less than min", function( assert ) {
+ assert.expect( 5 );
var element = $( "#spin" ).val( 50 ).spinner( {
min: 20,
step: 10
} );
simulateKeyDownUp( element, $.ui.keyCode.DOWN );
- equal( element.val(), 40 );
+ assert.equal( element.val(), 40 );
simulateKeyDownUp( element, $.ui.keyCode.DOWN );
- equal( element.val(), 30 );
+ assert.equal( element.val(), 30 );
simulateKeyDownUp( element, $.ui.keyCode.DOWN );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
simulateKeyDownUp( element, $.ui.keyCode.DOWN );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
simulateKeyDownUp( element, $.ui.keyCode.DOWN );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
} );
-test( "keydown PAGE_UP on input, increases value not greater than max", function() {
- expect( 5 );
+QUnit.test( "keydown PAGE_UP on input, increases value not greater than max", function( assert ) {
+ assert.expect( 5 );
var element = $( "#spin" ).val( 70 ).spinner( {
max: 100,
page: 10
} );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
- equal( element.val(), 80 );
+ assert.equal( element.val(), 80 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
- equal( element.val(), 90 );
+ assert.equal( element.val(), 90 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
- equal( element.val(), 100 );
+ assert.equal( element.val(), 100 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
- equal( element.val(), 100 );
+ assert.equal( element.val(), 100 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_UP );
- equal( element.val(), 100 );
+ assert.equal( element.val(), 100 );
} );
-test( "keydown PAGE_DOWN on input, decreases value not less than min", function() {
- expect( 5 );
+QUnit.test( "keydown PAGE_DOWN on input, decreases value not less than min", function( assert ) {
+ assert.expect( 5 );
var element = $( "#spin" ).val( 50 ).spinner( {
min: 20,
page: 10
} );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
- equal( element.val(), 40 );
+ assert.equal( element.val(), 40 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
- equal( element.val(), 30 );
+ assert.equal( element.val(), 30 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
simulateKeyDownUp( element, $.ui.keyCode.PAGE_DOWN );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
} );
-asyncTest( "blur input while spinning with UP", function() {
- expect( 3 );
+QUnit.test( "blur input while spinning with UP", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 3 );
var value,
element = $( "#spin" ).val( 10 ).spinner();
function step1() {
element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
- equal( element.val(), 11 );
+ assert.equal( element.val(), 11 );
setTimeout( step2, 750 );
}
function step2() {
value = element.val();
- ok( value > 11, "repeating while key is down" );
+ assert.ok( value > 11, "repeating while key is down" );
element.on( "blur", function() {
value = element.val();
@@ -121,137 +123,137 @@ asyncTest( "blur input while spinning with UP", function() {
}
function step3() {
- equal( element.val(), value, "stopped repeating on blur" );
- start();
+ assert.equal( element.val(), value, "stopped repeating on blur" );
+ ready();
}
element[ 0 ].focus();
setTimeout( step1 );
} );
-test( "mouse click on up button, increases value not greater than max", function() {
- expect( 3 );
+QUnit.test( "mouse click on up button, increases value not greater than max", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" ).val( 18 ).spinner( {
max: 20
} ),
button = element.spinner( "widget" ).find( ".ui-spinner-up" );
button.trigger( "mousedown" ).trigger( "mouseup" );
- equal( element.val(), 19 );
+ assert.equal( element.val(), 19 );
button.trigger( "mousedown" ).trigger( "mouseup" );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
button.trigger( "mousedown" ).trigger( "mouseup" );
- equal( element.val(), 20 );
+ assert.equal( element.val(), 20 );
} );
-test( "mouse click on up button, increases value not greater than max", function() {
- expect( 3 );
+QUnit.test( "mouse click on up button, increases value not greater than max", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" ).val( 2 ).spinner( {
min: 0
} ),
button = element.spinner( "widget" ).find( ".ui-spinner-down" );
button.trigger( "mousedown" ).trigger( "mouseup" );
- equal( element.val(), 1 );
+ assert.equal( element.val(), 1 );
button.trigger( "mousedown" ).trigger( "mouseup" );
- equal( element.val(), 0 );
+ assert.equal( element.val(), 0 );
button.trigger( "mousedown" ).trigger( "mouseup" );
- equal( element.val(), 0 );
+ assert.equal( element.val(), 0 );
} );
-test( "mousewheel on input", function() {
- expect( 4 );
+QUnit.test( "mousewheel on input", function( assert ) {
+ assert.expect( 4 );
var element = $( "#spin" ).val( 0 ).spinner( {
step: 2
} );
element.trigger( "mousewheel" );
- equal( element.val(), 0, "mousewheel event without delta does not change value" );
+ assert.equal( element.val(), 0, "mousewheel event without delta does not change value" );
element.trigger( "mousewheel", 1 );
- equal( element.val(), 2 );
+ assert.equal( element.val(), 2 );
element.trigger( "mousewheel", -0.2 );
- equal( element.val(), 0 );
+ assert.equal( element.val(), 0 );
element.trigger( "mousewheel", -15 );
- equal( element.val(), -2 );
+ assert.equal( element.val(), -2 );
} );
-test( "reading HTML5 attributes", function() {
- expect( 6 );
+QUnit.test( "reading HTML5 attributes", function( assert ) {
+ assert.expect( 6 );
var markup = "",
element = $( markup ).spinner();
- equal( element.spinner( "option", "min" ), -100, "min from markup" );
- equal( element.spinner( "option", "max" ), 100, "max from markup" );
- equal( element.spinner( "option", "step" ), 2, "step from markup" );
+ assert.equal( element.spinner( "option", "min" ), -100, "min from markup" );
+ assert.equal( element.spinner( "option", "max" ), 100, "max from markup" );
+ assert.equal( element.spinner( "option", "step" ), 2, "step from markup" );
element = $( markup ).spinner( {
min: -200,
max: 200,
step: 5
} );
- equal( element.spinner( "option", "min" ), -200, "min from options" );
- equal( element.spinner( "option", "max" ), 200, "max from options" );
- equal( element.spinner( "option", "step" ), 5, "stop from options" );
+ assert.equal( element.spinner( "option", "min" ), -200, "min from options" );
+ assert.equal( element.spinner( "option", "max" ), 200, "max from options" );
+ assert.equal( element.spinner( "option", "step" ), 5, "stop from options" );
} );
-test( "ARIA attributes", function() {
- expect( 9 );
+QUnit.test( "ARIA attributes", function( assert ) {
+ assert.expect( 9 );
var element = $( "#spin" ).val( 2 ).spinner( { min: -5, max: 5 } );
- equal( element.attr( "role" ), "spinbutton", "role" );
- equal( element.attr( "aria-valuemin" ), "-5", "aria-valuemin" );
- equal( element.attr( "aria-valuemax" ), "5", "aria-valuemax" );
- equal( element.attr( "aria-valuenow" ), "2", "aria-valuenow" );
+ assert.equal( element.attr( "role" ), "spinbutton", "role" );
+ assert.equal( element.attr( "aria-valuemin" ), "-5", "aria-valuemin" );
+ assert.equal( element.attr( "aria-valuemax" ), "5", "aria-valuemax" );
+ assert.equal( element.attr( "aria-valuenow" ), "2", "aria-valuenow" );
element.spinner( "stepUp" );
- equal( element.attr( "aria-valuenow" ), "3", "stepUp 1 step changes aria-valuenow" );
+ assert.equal( element.attr( "aria-valuenow" ), "3", "stepUp 1 step changes aria-valuenow" );
element.spinner( "option", { min: -10, max: 10 } );
- equal( element.attr( "aria-valuemin" ), "-10", "min option changed aria-valuemin changes" );
- equal( element.attr( "aria-valuemax" ), "10", "max option changed aria-valuemax changes" );
+ assert.equal( element.attr( "aria-valuemin" ), "-10", "min option changed aria-valuemin changes" );
+ assert.equal( element.attr( "aria-valuemax" ), "10", "max option changed aria-valuemax changes" );
element.spinner( "option", "min", null );
- equal( element.attr( "aria-valuemin" ), undefined, "aria-valuemin not set when no min" );
+ assert.equal( element.attr( "aria-valuemin" ), undefined, "aria-valuemin not set when no min" );
element.spinner( "option", "max", null );
- equal( element.attr( "aria-valuemax" ), undefined, "aria-valuemax not set when no max" );
+ assert.equal( element.attr( "aria-valuemax" ), undefined, "aria-valuemax not set when no max" );
} );
-test( "focus text field when pressing button", function() {
- expect( 2 );
+QUnit.test( "focus text field when pressing button", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).spinner();
$( "body" ).trigger( "focus" );
- ok( element[ 0 ] !== document.activeElement, "not focused before" );
+ assert.ok( element[ 0 ] !== document.activeElement, "not focused before" );
element.spinner( "widget" ).find( ".ui-spinner-up" ).trigger( "mousedown" );
- ok( element[ 0 ] === document.activeElement, "focused after" );
+ assert.ok( element[ 0 ] === document.activeElement, "focused after" );
} );
-test( "don't clear invalid value on blur", function() {
- expect( 1 );
+QUnit.test( "don't clear invalid value on blur", function( assert ) {
+ assert.expect( 1 );
var element = $( "#spin" ).spinner();
element.trigger( "focus" ).val( "a" ).trigger( "blur" );
- equal( element.val(), "a" );
+ assert.equal( element.val(), "a" );
} );
-test( "precision", function() {
- expect( 2 );
+QUnit.test( "precision", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0.05 ).spinner( {
step: 0.0001
} );
element.spinner( "stepUp" );
- equal( element.val(), "0.0501", "precision from step" );
+ assert.equal( element.val(), "0.0501", "precision from step" );
element.val( 1.05 ).spinner( "option", {
step: 1,
min: -9.95
} );
element.spinner( "stepDown" );
- equal( element.val(), "0.05", "precision from min" );
+ assert.equal( element.val(), "0.05", "precision from min" );
} );
} );
diff --git a/tests/unit/spinner/deprecated.js b/tests/unit/spinner/deprecated.js
index 6e177ba4b5a..baa36acf340 100644
--- a/tests/unit/spinner/deprecated.js
+++ b/tests/unit/spinner/deprecated.js
@@ -1,11 +1,12 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/spinner"
-], function( $ ) {
+], function( QUnit, $ ) {
var originalSpinner = $.ui.spinner.prototype;
-module( "spinner: deprecated", {
- setup: function() {
+QUnit.module( "spinner: deprecated", {
+ beforeEach: function() {
$.widget( "ui.spinner", $.ui.spinner, {
_uiSpinnerHtml: function() {
return "";
@@ -23,13 +24,13 @@ module( "spinner: deprecated", {
} );
},
- teardown: function() {
+ afterEach: function() {
$.ui.spinner.prototype = originalSpinner;
}
} );
-test( "markup structure - custom", function( assert ) {
- expect( 2 );
+QUnit.test( "markup structure - custom", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).spinner(),
spinner = element.spinner( "widget" ),
up = spinner.find( ".ui-spinner-up" );
diff --git a/tests/unit/spinner/events.js b/tests/unit/spinner/events.js
index 7f88d063a21..9c69470ab3c 100644
--- a/tests/unit/spinner/events.js
+++ b/tests/unit/spinner/events.js
@@ -1,20 +1,21 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/spinner"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
var simulateKeyDownUp = testHelper.simulateKeyDownUp;
-module( "spinner: events" );
+QUnit.module( "spinner: events" );
-test( "start", function() {
- expect( 10 );
+QUnit.test( "start", function( assert ) {
+ assert.expect( 10 );
var element = $( "#spin" ).spinner();
function shouldStart( expectation, msg ) {
element.spinner( "option", "start", function() {
- ok( expectation, msg );
+ assert.ok( expectation, msg );
} );
}
@@ -47,13 +48,13 @@ test( "start", function() {
element.spinner( "value", 999 );
} );
-test( "spin", function() {
- expect( 10 );
+QUnit.test( "spin", function( assert ) {
+ assert.expect( 10 );
var element = $( "#spin" ).spinner();
function shouldSpin( expectation, msg ) {
element.spinner( "option", "spin", function() {
- ok( expectation, msg );
+ assert.ok( expectation, msg );
} );
}
@@ -86,13 +87,13 @@ test( "spin", function() {
element.spinner( "value", 999 );
} );
-test( "stop", function() {
- expect( 10 );
+QUnit.test( "stop", function( assert ) {
+ assert.expect( 10 );
var element = $( "#spin" ).spinner();
function shouldStop( expectation, msg ) {
element.spinner( "option", "stop", function() {
- ok( expectation, msg );
+ assert.ok( expectation, msg );
} );
}
@@ -125,13 +126,14 @@ test( "stop", function() {
element.spinner( "value", 999 );
} );
-asyncTest( "change", function() {
- expect( 12 );
+QUnit.test( "change", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 12 );
var element = $( "#spin" ).spinner();
function shouldChange( expectation, msg ) {
element.spinner( "option", "change", function() {
- ok( expectation, msg );
+ assert.ok( expectation, msg );
} );
}
@@ -254,7 +256,7 @@ asyncTest( "change", function() {
shouldChange( false, "min, value not changed" );
element.spinner( "option", "min", 200 );
- start();
+ ready();
}
setTimeout( step1 );
diff --git a/tests/unit/spinner/methods.js b/tests/unit/spinner/methods.js
index 3b039ff3945..a7af2956db3 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" );
} );
} );
diff --git a/tests/unit/spinner/options.js b/tests/unit/spinner/options.js
index 8ad5caeaaa1..381e1b7fad6 100644
--- a/tests/unit/spinner/options.js
+++ b/tests/unit/spinner/options.js
@@ -1,16 +1,17 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/spinner",
"globalize",
"globalize/ja-JP"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "spinner: options" );
+QUnit.module( "spinner: options" );
-// culture is tested after numberFormat, since it depends on numberFormat
+// Culture is tested after numberFormat, since it depends on numberFormat
-test( "icons: default ", function( assert ) {
- expect( 4 );
+QUnit.test( "icons: default ", function( assert ) {
+ assert.expect( 4 );
var element = $( "#spin" ).val( 0 ).spinner();
assert.hasClasses( element.spinner( "widget" ).find( ".ui-icon:first" ),
"ui-icon ui-icon-triangle-1-n" );
@@ -27,8 +28,8 @@ test( "icons: default ", function( assert ) {
"ui-icon ui-icon-caret-1-s" );
} );
-test( "icons: custom ", function( assert ) {
- expect( 2 );
+QUnit.test( "icons: custom ", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0 ).spinner( {
icons: {
down: "custom-down",
@@ -39,15 +40,15 @@ test( "icons: custom ", function( assert ) {
assert.hasClasses( element.find( ".ui-icon:last" ), "ui-icon custom-down" );
} );
-test( "incremental, false", function() {
- expect( 100 );
+QUnit.test( "incremental, false", function( assert ) {
+ assert.expect( 100 );
var i,
prev = 0,
element = $( "#spin" ).val( prev ).spinner( {
incremental: false,
spin: function( event, ui ) {
- equal( ui.value - prev, 1 );
+ assert.equal( ui.value - prev, 1 );
prev = ui.value;
}
} );
@@ -58,8 +59,8 @@ test( "incremental, false", function() {
element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } );
} );
-test( "incremental, true", function() {
- expect( 100 );
+QUnit.test( "incremental, true", function( assert ) {
+ assert.expect( 100 );
function fill( num, val ) {
return $.map( new Array( num ), function() {
@@ -70,12 +71,12 @@ test( "incremental, true", function() {
var i,
prev = 0,
expected = [].concat( fill( 18, 1 ), fill( 37, 2 ), fill( 14, 3 ),
- fill( 9, 4 ), fill( 6, 5 ), fill( 5, 6 ), fill ( 5, 7 ),
+ fill( 9, 4 ), fill( 6, 5 ), fill( 5, 6 ), fill( 5, 7 ),
fill( 4, 8 ), fill( 2, 9 ) ),
element = $( "#spin" ).val( prev ).spinner( {
incremental: true,
spin: function( event, ui ) {
- equal( ui.value - prev, expected[ i ] );
+ assert.equal( ui.value - prev, expected[ i ] );
prev = ui.value;
}
} );
@@ -86,8 +87,8 @@ test( "incremental, true", function() {
element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } );
} );
-test( "incremental, function", function() {
- expect( 100 );
+QUnit.test( "incremental, function", function( assert ) {
+ assert.expect( 100 );
var i,
prev = 0,
@@ -96,7 +97,7 @@ test( "incremental, function", function() {
return i;
},
spin: function( event, ui ) {
- equal( ui.value - prev, i + 1 );
+ assert.equal( ui.value - prev, i + 1 );
prev = ui.value;
}
} );
@@ -107,86 +108,86 @@ test( "incremental, function", function() {
element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } );
} );
-test( "numberFormat, number", function() {
- expect( 2 );
+QUnit.test( "numberFormat, number", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "n" } );
- equal( element.val(), "0.00", "formatted on init" );
+ assert.equal( element.val(), "0.00", "formatted on init" );
element.spinner( "stepUp" );
- equal( element.val(), "1.00", "formatted after step" );
+ assert.equal( element.val(), "1.00", "formatted after step" );
} );
-test( "numberFormat, number, simple", function() {
- expect( 2 );
+QUnit.test( "numberFormat, number, simple", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "n0" } );
- equal( element.val(), "0", "formatted on init" );
+ assert.equal( element.val(), "0", "formatted on init" );
element.spinner( "stepUp" );
- equal( element.val(), "1", "formatted after step" );
+ assert.equal( element.val(), "1", "formatted after step" );
} );
-test( "numberFormat, currency", function() {
- expect( 2 );
+QUnit.test( "numberFormat, currency", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "C" } );
- equal( element.val(), "$0.00", "formatted on init" );
+ assert.equal( element.val(), "$0.00", "formatted on init" );
element.spinner( "stepUp" );
- equal( element.val(), "$1.00", "formatted after step" );
+ assert.equal( element.val(), "$1.00", "formatted after step" );
} );
-test( "numberFormat, change", function() {
- expect( 2 );
+QUnit.test( "numberFormat, change", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 5 ).spinner( { numberFormat: "n1" } );
- equal( element.val(), "5.0", "formatted on init" );
+ assert.equal( element.val(), "5.0", "formatted on init" );
element.spinner( "option", "numberFormat", "c" );
- equal( element.val(), "$5.00", "formatted after change" );
+ assert.equal( element.val(), "$5.00", "formatted after change" );
} );
-test( "culture, null", function() {
- expect( 2 );
+QUnit.test( "culture, null", function( assert ) {
+ assert.expect( 2 );
Globalize.culture( "ja-JP" );
var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "C" } );
- equal( element.val(), "¥0", "formatted on init" );
+ assert.equal( element.val(), "¥0", "formatted on init" );
element.spinner( "stepUp" );
- equal( element.val(), "¥1", "formatted after step" );
+ assert.equal( element.val(), "¥1", "formatted after step" );
// Reset culture
Globalize.culture( "default" );
} );
-test( "currency, ja-JP", function() {
- expect( 2 );
+QUnit.test( "currency, ja-JP", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0 ).spinner( {
numberFormat: "C",
culture: "ja-JP"
} );
- equal( element.val(), "¥0", "formatted on init" );
+ assert.equal( element.val(), "¥0", "formatted on init" );
element.spinner( "stepUp" );
- equal( element.val(), "¥1", "formatted after step" );
+ assert.equal( element.val(), "¥1", "formatted after step" );
} );
-test( "currency, change", function() {
- expect( 2 );
+QUnit.test( "currency, change", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 5 ).spinner( {
numberFormat: "C",
culture: "ja-JP"
} );
- equal( element.val(), "¥5", "formatted on init" );
+ assert.equal( element.val(), "¥5", "formatted on init" );
element.spinner( "option", "culture", "en" );
- equal( element.val(), "$5.00", "formatted after change" );
+ assert.equal( element.val(), "$5.00", "formatted after change" );
} );
-test( "max", function() {
- expect( 3 );
+QUnit.test( "max", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" ).val( 1000 ).spinner( { max: 100 } );
- equal( element.val(), 1000, "value not constrained on init" );
+ assert.equal( element.val(), 1000, "value not constrained on init" );
element.spinner( "value", 1000 );
- equal( element.val(), 100, "max constrained in value method" );
+ assert.equal( element.val(), 100, "max constrained in value method" );
element.val( 1000 ).trigger( "blur" );
- equal( element.val(), 1000, "max not constrained if manual entry" );
+ assert.equal( element.val(), 1000, "max not constrained if manual entry" );
} );
-test( "max, string", function() {
- expect( 3 );
+QUnit.test( "max, string", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" )
.val( 1000 )
.spinner( {
@@ -194,27 +195,27 @@ test( "max, string", function() {
numberFormat: "C",
culture: "en"
} );
- equal( element.val(), "$1,000.00", "value not constrained on init" );
- equal( element.spinner( "option", "max" ), 100, "option converted to number" );
+ assert.equal( element.val(), "$1,000.00", "value not constrained on init" );
+ assert.equal( element.spinner( "option", "max" ), 100, "option converted to number" );
element.spinner( "value", 1000 );
- equal( element.val(), "$100.00", "max constrained in value method" );
+ assert.equal( element.val(), "$100.00", "max constrained in value method" );
} );
-test( "min", function() {
- expect( 3 );
+QUnit.test( "min", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" ).val( -1000 ).spinner( { min: -100 } );
- equal( element.val(), -1000, "value not constrained on init" );
+ assert.equal( element.val(), -1000, "value not constrained on init" );
element.spinner( "value", -1000 );
- equal( element.val(), -100, "min constrained in value method" );
+ assert.equal( element.val(), -100, "min constrained in value method" );
element.val( -1000 ).trigger( "blur" );
- equal( element.val(), -1000, "min not constrained if manual entry" );
+ assert.equal( element.val(), -1000, "min not constrained if manual entry" );
} );
-test( "min, string", function() {
- expect( 3 );
+QUnit.test( "min, string", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" )
.val( -1000 )
.spinner( {
@@ -222,50 +223,50 @@ test( "min, string", function() {
numberFormat: "C",
culture: "en"
} );
- equal( element.val(), "($1,000.00)", "value not constrained on init" );
- equal( element.spinner( "option", "min" ), -100, "option converted to number" );
+ assert.equal( element.val(), "($1,000.00)", "value not constrained on init" );
+ assert.equal( element.spinner( "option", "min" ), -100, "option converted to number" );
element.spinner( "value", -1000 );
- equal( element.val(), "($100.00)", "min constrained in value method" );
+ assert.equal( element.val(), "($100.00)", "min constrained in value method" );
} );
-test( "step, 2", function() {
- expect( 3 );
+QUnit.test( "step, 2", function( assert ) {
+ assert.expect( 3 );
var element = $( "#spin" ).val( 0 ).spinner( { step: 2 } );
element.spinner( "stepUp" );
- equal( element.val(), "2", "stepUp" );
+ assert.equal( element.val(), "2", "stepUp" );
element.spinner( "value", "10.5" );
- equal( element.val(), "10", "value reset to 10" );
+ assert.equal( element.val(), "10", "value reset to 10" );
element.val( "4.5" );
element.spinner( "stepUp" );
- equal( element.val(), "6", "stepUp" );
+ assert.equal( element.val(), "6", "stepUp" );
} );
-test( "step, 0.7", function() {
- expect( 1 );
+QUnit.test( "step, 0.7", function( assert ) {
+ assert.expect( 1 );
var element = $( "#spin" ).val( 0 ).spinner( {
step: 0.7
} );
element.spinner( "stepUp" );
- equal( element.val(), "0.7", "stepUp" );
+ assert.equal( element.val(), "0.7", "stepUp" );
} );
-test( "step, string", function() {
- expect( 2 );
+QUnit.test( "step, string", function( assert ) {
+ assert.expect( 2 );
var element = $( "#spin" ).val( 0 ).spinner( {
step: "$0.70",
numberFormat: "C",
culture: "en"
} );
- equal( element.spinner( "option", "step" ), 0.7, "option converted to number" );
+ assert.equal( element.spinner( "option", "step" ), 0.7, "option converted to number" );
element.spinner( "stepUp" );
- equal( element.val(), "$0.70", "stepUp" );
+ assert.equal( element.val(), "$0.70", "stepUp" );
} );
} );
From bfcd6358fe1d088f4d0ecd3632182578c0bfb865 Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Wed, 6 Apr 2016 19:18:50 +0530
Subject: [PATCH 22/26] Tabs: Shift to use no globals
---
tests/unit/tabs/core.js | 657 +++++++++++++++++++------------------
tests/unit/tabs/events.js | 294 ++++++++---------
tests/unit/tabs/helper.js | 22 +-
tests/unit/tabs/methods.js | 197 +++++------
tests/unit/tabs/options.js | 242 +++++++-------
5 files changed, 712 insertions(+), 700 deletions(-)
diff --git a/tests/unit/tabs/core.js b/tests/unit/tabs/core.js
index a2b41e24c8c..c0097ecfb36 100644
--- a/tests/unit/tabs/core.js
+++ b/tests/unit/tabs/core.js
@@ -1,15 +1,16 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/tabs"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
var state = testHelper.state;
-module( "tabs: core" );
+QUnit.module( "tabs: core" );
-test( "markup structure", function( assert ) {
- expect( 20 );
+QUnit.test( "markup structure", function( assert ) {
+ assert.expect( 20 );
var element = $( "#tabs1" ).tabs(),
tabList = element.find( "ul, ol" ),
tabs = tabList.find( "li" ),
@@ -20,7 +21,7 @@ test( "markup structure", function( assert ) {
assert.hasClasses( element, "ui-tabs ui-widget ui-widget-content" );
assert.lacksClasses( element, "ui-tabs-collapsible" );
assert.hasClasses( tabList, "ui-tabs-nav ui-widget-header" );
- equal( tabList.length, 1, "The widget contains exactly one tab list" );
+ assert.equal( tabList.length, 1, "The widget contains exactly one tab list" );
assert.hasClasses( tabs[ 0 ], "ui-tabs-tab" );
assert.hasClasses( tabs[ 1 ], "ui-tabs-tab" );
assert.hasClasses( tabs[ 2 ], "ui-tabs-tab" );
@@ -30,16 +31,16 @@ test( "markup structure", function( assert ) {
assert.hasClasses( tabs[ 1 ], "ui-tab" );
assert.hasClasses( tabs[ 2 ], "ui-tab" );
- equal( tabs.length, 3, "There are exactly three tabs" );
+ assert.equal( tabs.length, 3, "There are exactly three tabs" );
assert.hasClasses( anchors[ 0 ], "ui-tabs-anchor" );
assert.hasClasses( anchors[ 1 ], "ui-tabs-anchor" );
assert.hasClasses( anchors[ 2 ], "ui-tabs-anchor" );
- equal( anchors.length, 3, "There are exactly 3 anchors" );
+ assert.equal( anchors.length, 3, "There are exactly 3 anchors" );
assert.hasClasses( active, "ui-tabs-active" );
assert.hasClasses( panels[ 0 ], "ui-tabs-panel ui-widget-content" );
assert.hasClasses( panels[ 1 ], "ui-tabs-panel ui-widget-content" );
assert.hasClasses( panels[ 2 ], "ui-tabs-panel ui-widget-content" );
- equal( panels.length, 3, "There are exactly 3 tab panels" );
+ assert.equal( panels.length, 3, "There are exactly 3 tab panels" );
} );
$.each( {
@@ -48,8 +49,8 @@ $.each( {
"multiple lists, ol first": "#tabs5",
"empty list": "#tabs6"
}, function( type, selector ) {
- test( "markup structure: " + type, function( assert ) {
- expect( 2 );
+ QUnit.test( "markup structure: " + type, function( assert ) {
+ assert.expect( 2 );
var element = $( selector ).tabs();
assert.hasClasses( element, "ui-tabs" );
assert.hasClasses( $( selector + "-list" ), "ui-tabs-nav" );
@@ -57,50 +58,50 @@ $.each( {
} );
// #5893 - Sublist in the tab list are considered as tab
-test( "nested list", function() {
- expect( 1 );
+QUnit.test( "nested list", function( assert ) {
+ assert.expect( 1 );
var element = $( "#tabs6" ).tabs();
- equal( element.tabs( "instance" ).anchors.length, 2, "should contain 2 tab" );
+ assert.equal( element.tabs( "instance" ).anchors.length, 2, "should contain 2 tab" );
} );
-test( "disconnected from DOM", function() {
- expect( 2 );
+QUnit.test( "disconnected from DOM", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tabs1" ).remove().tabs();
- equal( element.find( ".ui-tabs-nav" ).length, 1, "should initialize nav" );
- equal( element.find( ".ui-tabs-panel" ).length, 3, "should initialize panels" );
+ assert.equal( element.find( ".ui-tabs-nav" ).length, 1, "should initialize nav" );
+ assert.equal( element.find( ".ui-tabs-panel" ).length, 3, "should initialize panels" );
} );
-test( "non-tab list items", function() {
- expect( 2 );
+QUnit.test( "non-tab list items", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tabs9" ).tabs();
- equal( element.tabs( "option", "active" ), 0, "defaults to first tab" );
- equal( element.find( ".ui-tabs-nav li.ui-state-active" ).index(), 1,
+ assert.equal( element.tabs( "option", "active" ), 0, "defaults to first tab" );
+ assert.equal( element.find( ".ui-tabs-nav li.ui-state-active" ).index(), 1,
"first actual tab is active" );
} );
-test( "aria-controls", function() {
- expect( 7 );
+QUnit.test( "aria-controls", function( assert ) {
+ assert.expect( 7 );
var element = $( "#tabs1" ).tabs(),
tabs = element.find( ".ui-tabs-nav li" );
tabs.each( function() {
var tab = $( this ),
anchor = tab.find( ".ui-tabs-anchor" );
- equal( anchor.prop( "hash" ).substring( 1 ), tab.attr( "aria-controls" ) );
+ assert.equal( anchor.prop( "hash" ).substring( 1 ), tab.attr( "aria-controls" ) );
} );
element = $( "#tabs2" ).tabs();
tabs = element.find( ".ui-tabs-nav li" );
- equal( tabs.eq( 0 ).attr( "aria-controls" ), "colon:test" );
- equal( tabs.eq( 1 ).attr( "aria-controls" ), "inline-style" );
- ok( /^ui-id-\d+$/.test( tabs.eq( 2 ).attr( "aria-controls" ) ), "generated id" );
- equal( tabs.eq( 3 ).attr( "aria-controls" ), "custom-id" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-controls" ), "colon:test" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-controls" ), "inline-style" );
+ assert.ok( /^ui-id-\d+$/.test( tabs.eq( 2 ).attr( "aria-controls" ) ), "generated id" );
+ assert.equal( tabs.eq( 3 ).attr( "aria-controls" ), "custom-id" );
} );
-test( "accessibility", function() {
- expect( 49 );
+QUnit.test( "accessibility", function( assert ) {
+ assert.expect( 49 );
var element = $( "#tabs1" ).tabs( {
active: 1,
disabled: [ 2 ]
@@ -109,76 +110,78 @@ test( "accessibility", function() {
anchors = tabs.find( ".ui-tabs-anchor" ),
panels = element.find( ".ui-tabs-panel" );
- equal( element.find( ".ui-tabs-nav" ).attr( "role" ), "tablist", "tablist role" );
+ assert.equal( element.find( ".ui-tabs-nav" ).attr( "role" ), "tablist", "tablist role" );
tabs.each( function( index ) {
var tab = tabs.eq( index ),
anchor = anchors.eq( index ),
anchorId = anchor.attr( "id" ),
panel = panels.eq( index );
- equal( tab.attr( "role" ), "tab", "tab " + index + " role" );
- equal( tab.attr( "aria-labelledby" ), anchorId, "tab " + index + " aria-labelledby" );
- equal( anchor.attr( "role" ), "presentation", "anchor " + index + " role" );
- equal( anchor.attr( "tabindex" ), -1, "anchor " + index + " tabindex" );
- equal( panel.attr( "role" ), "tabpanel", "panel " + index + " role" );
- equal( panel.attr( "aria-labelledby" ), anchorId, "panel " + index + " aria-labelledby" );
+ assert.equal( tab.attr( "role" ), "tab", "tab " + index + " role" );
+ assert.equal( tab.attr( "aria-labelledby" ), anchorId, "tab " + index + " aria-labelledby" );
+ assert.equal( anchor.attr( "role" ), "presentation", "anchor " + index + " role" );
+ assert.equal( anchor.attr( "tabindex" ), -1, "anchor " + index + " tabindex" );
+ assert.equal( panel.attr( "role" ), "tabpanel", "panel " + index + " role" );
+ assert.equal( panel.attr( "aria-labelledby" ), anchorId, "panel " + index + " aria-labelledby" );
} );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "active tab has aria-selected=true" );
- equal( tabs.eq( 1 ).attr( "tabindex" ), 0, "active tab has tabindex=0" );
- equal( tabs.eq( 1 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "active tab has aria-expanded=true" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "active panel has aria-hidden=false" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
- equal( tabs.eq( 0 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
- equal( tabs.eq( 0 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
- equal( tabs.eq( 2 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
- equal( tabs.eq( 2 ).attr( "aria-disabled" ), "true", "disabled tab has aria-disabled=true" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "active tab has aria-selected=true" );
+ assert.equal( tabs.eq( 1 ).attr( "tabindex" ), 0, "active tab has tabindex=0" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "active tab has aria-expanded=true" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "active panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+ assert.equal( tabs.eq( 0 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+ assert.equal( tabs.eq( 2 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-disabled" ), "true", "disabled tab has aria-disabled=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
element.tabs( "option", "active", 0 );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "active tab has aria-selected=true" );
- equal( tabs.eq( 0 ).attr( "tabindex" ), 0, "active tab has tabindex=0" );
- equal( tabs.eq( 0 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "active tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "active panel has aria-hidden=false" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
- equal( tabs.eq( 1 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
- equal( tabs.eq( 1 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
- equal( tabs.eq( 2 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
- equal( tabs.eq( 2 ).attr( "aria-disabled" ), "true", "disabled tab has aria-disabled=true" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "active tab has aria-selected=true" );
+ assert.equal( tabs.eq( 0 ).attr( "tabindex" ), 0, "active tab has tabindex=0" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "active tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "active panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+ assert.equal( tabs.eq( 1 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+ assert.equal( tabs.eq( 2 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-disabled" ), "true", "disabled tab has aria-disabled=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
} );
-asyncTest( "accessibility - ajax", function( assert ) {
- expect( 6 );
+QUnit.test( "accessibility - ajax", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 6 );
var element = $( "#tabs2" ).tabs(),
tab = element.find( ".ui-tabs-nav li" ).eq( 3 ),
panel = $( "#custom-id" );
- equal( panel.attr( "aria-live" ), "polite", "remote panel has aria-live" );
- equal( panel.attr( "aria-busy" ), null, "does not have aria-busy on init" );
+ assert.equal( panel.attr( "aria-live" ), "polite", "remote panel has aria-live" );
+ assert.equal( panel.attr( "aria-busy" ), null, "does not have aria-busy on init" );
element.tabs( "option", "active", 3 );
assert.hasClasses( tab, "ui-tabs-loading" );
- equal( panel.attr( "aria-busy" ), "true", "panel has aria-busy during load" );
+ assert.equal( panel.attr( "aria-busy" ), "true", "panel has aria-busy during load" );
element.one( "tabsload", function() {
setTimeout( function() {
- equal( panel.attr( "aria-busy" ), null, "panel does not have aria-busy after load" );
+ assert.equal( panel.attr( "aria-busy" ), null, "panel does not have aria-busy after load" );
assert.lacksClasses( tab, "ui-tabs-loading" );
- start();
+ ready();
}, 1 );
} );
} );
-asyncTest( "keyboard support - LEFT, RIGHT, UP, DOWN, HOME, END, SPACE, ENTER", function( assert ) {
- expect( 92 );
+QUnit.test( "keyboard support - LEFT, RIGHT, UP, DOWN, HOME, END, SPACE, ENTER", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 92 );
var element = $( "#tabs1" ).tabs( {
collapsible: true
} ),
@@ -188,92 +191,92 @@ asyncTest( "keyboard support - LEFT, RIGHT, UP, DOWN, HOME, END, SPACE, ENTER",
element.tabs( "instance" ).delay = 1;
- equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
+ assert.equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
tabs.eq( 0 ).simulate( "focus" );
// Down, right, down (wrap), up (wrap)
function step1() {
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "first tab has focus" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.DOWN } );
assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "DOWN moves focus to next tab" );
assert.lacksClasses( tabs.eq( 0 ), "ui-state-focus", "first tab is no longer focused" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
tabs.eq( 1 ).simulate( "keydown", { keyCode: keyCode.RIGHT } );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "RIGHT moves focus to next tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.DOWN } );
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "DOWN wraps focus to first tab" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.UP } );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "UP wraps focus to last tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step2, 25 );
}
// Left, home, space
function step2() {
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.LEFT } );
assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "LEFT moves focus to previous tab" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is still visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is still visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
tabs.eq( 1 ).simulate( "keydown", { keyCode: keyCode.HOME } );
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "HOME moves focus to first tab" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel is still hidden" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is still visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is still hidden" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is still visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
// SPACE activates, cancels delay
tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.SPACE } );
@@ -282,25 +285,25 @@ asyncTest( "keyboard support - LEFT, RIGHT, UP, DOWN, HOME, END, SPACE, ENTER",
// End, enter
function step3() {
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tabs has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tabs has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.END } );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "END moves focus to last tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tabs has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tabs has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
// ENTER activates, cancels delay
tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.ENTER } );
@@ -309,22 +312,22 @@ asyncTest( "keyboard support - LEFT, RIGHT, UP, DOWN, HOME, END, SPACE, ENTER",
// Enter (collapse)
function step4() {
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
// ENTER collapses if active
tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.ENTER } );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- setTimeout( start );
+ setTimeout( ready );
}
setTimeout( step1 );
@@ -335,8 +338,9 @@ $.each( {
ctrl: "CTRL",
meta: "COMMAND"
}, function( modifier, label ) {
- asyncTest( "keyboard support - " + label + " navigation", function( assert ) {
- expect( 115 );
+ QUnit.test( "keyboard support - " + label + " navigation", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 115 );
var element = $( "#tabs1" ).tabs(),
tabs = element.find( ".ui-tabs-nav li" ),
panels = element.find( ".ui-tabs-panel" ),
@@ -344,7 +348,7 @@ $.each( {
element.tabs( "instance" ).delay = 1;
- equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
+ assert.equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
tabs.eq( 0 ).simulate( "focus" );
// Down
@@ -353,20 +357,20 @@ $.each( {
eventProperties[ modifier + "Key" ] = true;
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "first tab has focus" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
tabs.eq( 0 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "DOWN moves focus to next tab" );
assert.lacksClasses( tabs.eq( 0 ), ".ui-state-focus", "first tab is no longer focused" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step2, 25 );
}
@@ -376,24 +380,24 @@ $.each( {
var eventProperties = { keyCode: keyCode.RIGHT };
eventProperties[ modifier + "Key" ] = true;
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
tabs.eq( 1 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "RIGHT moves focus to next tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step3, 25 );
}
@@ -403,20 +407,20 @@ $.each( {
var eventProperties = { keyCode: keyCode.DOWN };
eventProperties[ modifier + "Key" ] = true;
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
tabs.eq( 2 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "DOWN wraps focus to first tab" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step4, 25 );
}
@@ -426,21 +430,21 @@ $.each( {
var eventProperties = { keyCode: keyCode.UP };
eventProperties[ modifier + "Key" ] = true;
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
tabs.eq( 0 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "UP wraps focus to last tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step5, 25 );
}
@@ -450,24 +454,24 @@ $.each( {
var eventProperties = { keyCode: keyCode.LEFT };
eventProperties[ modifier + "Key" ] = true;
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
tabs.eq( 2 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "LEFT moves focus to previous tab" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step6, 25 );
}
@@ -477,24 +481,24 @@ $.each( {
var eventProperties = { keyCode: keyCode.HOME };
eventProperties[ modifier + "Key" ] = true;
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
tabs.eq( 1 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "HOME moves focus to first tab" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step7, 25 );
}
@@ -504,170 +508,171 @@ $.each( {
var eventProperties = { keyCode: keyCode.END };
eventProperties[ modifier + "Key" ] = true;
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
tabs.eq( 0 ).simulate( "keydown", eventProperties );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "END moves focus to last tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
setTimeout( step8, 25 );
}
// Space
function step8() {
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.SPACE } );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
-
- setTimeout( start );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+
+ setTimeout( ready );
}
setTimeout( step1 );
} );
} );
-asyncTest( "keyboard support - CTRL+UP, ALT+PAGE_DOWN, ALT+PAGE_UP", function( assert ) {
- expect( 50 );
+QUnit.test( "keyboard support - CTRL+UP, ALT+PAGE_DOWN, ALT+PAGE_UP", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 50 );
var element = $( "#tabs1" ).tabs(),
tabs = element.find( ".ui-tabs-nav li" ),
panels = element.find( ".ui-tabs-panel" ),
keyCode = $.ui.keyCode;
- equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
+ assert.equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
panels.attr( "tabindex", -1 );
panels.eq( 0 ).simulate( "focus" );
function step1() {
- strictEqual( document.activeElement, panels[ 0 ], "first panel is activeElement" );
+ assert.strictEqual( document.activeElement, panels[ 0 ], "first panel is activeElement" );
panels.eq( 0 ).simulate( "keydown", { keyCode: keyCode.PAGE_DOWN, altKey: true } );
- strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
+ assert.strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "ALT+PAGE_DOWN moves focus to next tab" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
- ok( panels.eq( 1 ).is( ":visible" ), "second panel is visible" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "second tab has aria-expanded=true" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "second panel has aria-hidden=false" );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+ assert.ok( panels.eq( 1 ).is( ":visible" ), "second panel is visible" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "second tab has aria-expanded=true" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "second panel has aria-hidden=false" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
tabs.eq( 1 ).simulate( "keydown", { keyCode: keyCode.PAGE_DOWN, altKey: true } );
- strictEqual( document.activeElement, tabs[ 2 ], "third tab is activeElement" );
+ assert.strictEqual( document.activeElement, tabs[ 2 ], "third tab is activeElement" );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "ALT+PAGE_DOWN moves focus to next tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
- ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.PAGE_DOWN, altKey: true } );
- strictEqual( document.activeElement, tabs[ 0 ], "first tab is activeElement" );
+ assert.strictEqual( document.activeElement, tabs[ 0 ], "first tab is activeElement" );
assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "ALT+PAGE_DOWN wraps focus to first tab" );
- equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
- ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
panels.eq( 0 ).simulate( "focus" );
setTimeout( step2 );
}
function step2() {
- strictEqual( document.activeElement, panels[ 0 ], "first panel is activeElement" );
+ assert.strictEqual( document.activeElement, panels[ 0 ], "first panel is activeElement" );
panels.eq( 0 ).simulate( "keydown", { keyCode: keyCode.PAGE_UP, altKey: true } );
- strictEqual( document.activeElement, tabs[ 2 ], "third tab is activeElement" );
+ assert.strictEqual( document.activeElement, tabs[ 2 ], "third tab is activeElement" );
assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "ALT+PAGE_UP wraps focus to last tab" );
- equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
- ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
- equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
- equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+ assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+ assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+ assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.PAGE_UP, altKey: true } );
- strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
+ assert.strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "ALT+PAGE_UP moves focus to previous tab" );
- equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
- ok( panels.eq( 1 ).is( ":visible" ), "second panel is visible" );
- equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "second tab has aria-expanded=true" );
- equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "second panel has aria-hidden=false" );
- ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
- equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
- equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+ assert.ok( panels.eq( 1 ).is( ":visible" ), "second panel is visible" );
+ assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "second tab has aria-expanded=true" );
+ assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "second panel has aria-hidden=false" );
+ assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+ assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+ assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
panels.eq( 1 ).simulate( "focus" );
setTimeout( step3 );
}
function step3() {
- strictEqual( document.activeElement, panels[ 1 ], "second panel is activeElement" );
+ assert.strictEqual( document.activeElement, panels[ 1 ], "second panel is activeElement" );
panels.eq( 1 ).simulate( "keydown", { keyCode: keyCode.UP, ctrlKey: true } );
- strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
+ assert.strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
- setTimeout( start );
+ setTimeout( ready );
}
setTimeout( step1 );
} );
-test( "#3627 - Ajax tab with url containing a fragment identifier fails to load", function() {
- expect( 1 );
+QUnit.test( "#3627 - Ajax tab with url containing a fragment identifier fails to load", function( assert ) {
+ assert.expect( 1 );
$( "#tabs2" ).tabs( {
active: 2,
beforeLoad: function( event, ui ) {
event.preventDefault();
- ok( /test.html$/.test( ui.ajaxSettings.url ), "should ignore fragment identifier" );
+ assert.ok( /test.html$/.test( ui.ajaxSettings.url ), "should ignore fragment identifier" );
}
} );
} );
-test( "#4033 - IE expands hash to full url and misinterprets tab as ajax", function() {
- expect( 2 );
+QUnit.test( "#4033 - IE expands hash to full url and misinterprets tab as ajax", function( assert ) {
+ assert.expect( 2 );
var element = $( "" );
element.appendTo( "#qunit-fixture" );
element.tabs( {
beforeLoad: function() {
event.preventDefault();
- ok( false, "should not be an ajax tab" );
+ assert.ok( false, "should not be an ajax tab" );
}
} );
- equal( element.find( ".ui-tabs-nav li" ).attr( "aria-controls" ), "tab", "aria-contorls attribute is correct" );
- state( element, 1 );
+ assert.equal( element.find( ".ui-tabs-nav li" ).attr( "aria-controls" ), "tab", "aria-contorls attribute is correct" );
+ state( assert, element, 1 );
} );
} );
diff --git a/tests/unit/tabs/events.js b/tests/unit/tabs/events.js
index 736fda503a7..757e2bada0f 100644
--- a/tests/unit/tabs/events.js
+++ b/tests/unit/tabs/events.js
@@ -1,15 +1,16 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/tabs"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
var state = testHelper.state;
-module( "tabs: events" );
+QUnit.module( "tabs: events" );
-test( "create", function() {
- expect( 10 );
+QUnit.test( "create", function( assert ) {
+ assert.expect( 10 );
var element = $( "#tabs1" ),
tabs = element.find( "ul li" ),
@@ -17,10 +18,10 @@ test( "create", function() {
element.tabs( {
create: function( event, ui ) {
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tabs[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panels[ 0 ], "panel" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tabs[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panels[ 0 ], "panel" );
}
} );
element.tabs( "destroy" );
@@ -28,10 +29,10 @@ test( "create", function() {
element.tabs( {
active: 2,
create: function( event, ui ) {
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tabs[ 2 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panels[ 2 ], "panel" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tabs[ 2 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panels[ 2 ], "panel" );
}
} );
element.tabs( "destroy" );
@@ -40,15 +41,15 @@ test( "create", function() {
active: false,
collapsible: true,
create: function( event, ui ) {
- equal( ui.tab.length, 0, "tab length" );
- equal( ui.panel.length, 0, "panel length" );
+ assert.equal( ui.tab.length, 0, "tab length" );
+ assert.equal( ui.panel.length, 0, "panel length" );
}
} );
element.tabs( "destroy" );
} );
-test( "beforeActivate", function() {
- expect( 38 );
+QUnit.test( "beforeActivate", function( assert ) {
+ assert.expect( 38 );
var element = $( "#tabs1" ).tabs( {
active: false,
@@ -60,66 +61,66 @@ test( "beforeActivate", function() {
// From collapsed
element.one( "tabsbeforeactivate", function( event, ui ) {
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.oldTab.length, 0, "oldTab length" );
- equal( ui.oldPanel.length, 0, "oldPanel length" );
- equal( ui.newTab.length, 1, "newTab length" );
- strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
- equal( ui.newPanel.length, 1, "newPanel length" );
- strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
- state( element, 0, 0, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.oldTab.length, 0, "oldTab length" );
+ assert.equal( ui.oldPanel.length, 0, "oldPanel length" );
+ assert.equal( ui.newTab.length, 1, "newTab length" );
+ assert.strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
+ assert.equal( ui.newPanel.length, 1, "newPanel length" );
+ assert.strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
+ state( assert, element, 0, 0, 0 );
} );
element.tabs( "option", "active", 0 );
- state( element, 1, 0, 0 );
+ state( assert, element, 1, 0, 0 );
// Switching tabs
element.one( "tabsbeforeactivate", function( event, ui ) {
- equal( event.originalEvent.type, "click", "originalEvent" );
- equal( ui.oldTab.length, 1, "oldTab length" );
- strictEqual( ui.oldTab[ 0 ], tabs[ 0 ], "oldTab" );
- equal( ui.oldPanel.length, 1, "oldPanel length" );
- strictEqual( ui.oldPanel[ 0 ], panels[ 0 ], "oldPanel" );
- equal( ui.newTab.length, 1, "newTab length" );
- strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
- equal( ui.newPanel.length, 1, "newPanel length" );
- strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
- state( element, 1, 0, 0 );
+ assert.equal( event.originalEvent.type, "click", "originalEvent" );
+ assert.equal( ui.oldTab.length, 1, "oldTab length" );
+ assert.strictEqual( ui.oldTab[ 0 ], tabs[ 0 ], "oldTab" );
+ assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+ assert.strictEqual( ui.oldPanel[ 0 ], panels[ 0 ], "oldPanel" );
+ assert.equal( ui.newTab.length, 1, "newTab length" );
+ assert.strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
+ assert.equal( ui.newPanel.length, 1, "newPanel length" );
+ assert.strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
+ state( assert, element, 1, 0, 0 );
} );
anchors.eq( 1 ).trigger( "click" );
- state( element, 0, 1, 0 );
+ state( assert, element, 0, 1, 0 );
// Collapsing
element.one( "tabsbeforeactivate", function( event, ui ) {
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.oldTab.length, 1, "oldTab length" );
- strictEqual( ui.oldTab[ 0 ], tabs[ 1 ], "oldTab" );
- equal( ui.oldPanel.length, 1, "oldPanel length" );
- strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
- equal( ui.newTab.length, 0, "newTab length" );
- equal( ui.newPanel.length, 0, "newPanel length" );
- state( element, 0, 1, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.oldTab.length, 1, "oldTab length" );
+ assert.strictEqual( ui.oldTab[ 0 ], tabs[ 1 ], "oldTab" );
+ assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+ assert.strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
+ assert.equal( ui.newTab.length, 0, "newTab length" );
+ assert.equal( ui.newPanel.length, 0, "newPanel length" );
+ state( assert, element, 0, 1, 0 );
} );
element.tabs( "option", "active", false );
- state( element, 0, 0, 0 );
+ state( assert, element, 0, 0, 0 );
// Prevent activation
element.one( "tabsbeforeactivate", function( event, ui ) {
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.oldTab.length, 0, "oldTab length" );
- equal( ui.oldPanel.length, 0, "oldTab" );
- equal( ui.newTab.length, 1, "newTab length" );
- strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
- equal( ui.newPanel.length, 1, "newPanel length" );
- strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.oldTab.length, 0, "oldTab length" );
+ assert.equal( ui.oldPanel.length, 0, "oldTab" );
+ assert.equal( ui.newTab.length, 1, "newTab length" );
+ assert.strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
+ assert.equal( ui.newPanel.length, 1, "newPanel length" );
+ assert.strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
event.preventDefault();
- state( element, 0, 0, 0 );
+ state( assert, element, 0, 0, 0 );
} );
element.tabs( "option", "active", 1 );
- state( element, 0, 0, 0 );
+ state( assert, element, 0, 0, 0 );
} );
-test( "activate", function() {
- expect( 30 );
+QUnit.test( "activate", function( assert ) {
+ assert.expect( 30 );
var element = $( "#tabs1" ).tabs( {
active: false,
@@ -131,61 +132,61 @@ test( "activate", function() {
// From collapsed
element.one( "tabsactivate", function( event, ui ) {
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.oldTab.length, 0, "oldTab length" );
- equal( ui.oldPanel.length, 0, "oldPanel length" );
- equal( ui.newTab.length, 1, "newTab length" );
- strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
- equal( ui.newPanel.length, 1, "newPanel length" );
- strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
- state( element, 1, 0, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.oldTab.length, 0, "oldTab length" );
+ assert.equal( ui.oldPanel.length, 0, "oldPanel length" );
+ assert.equal( ui.newTab.length, 1, "newTab length" );
+ assert.strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
+ assert.equal( ui.newPanel.length, 1, "newPanel length" );
+ assert.strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
+ state( assert, element, 1, 0, 0 );
} );
element.tabs( "option", "active", 0 );
- state( element, 1, 0, 0 );
+ state( assert, element, 1, 0, 0 );
// Switching tabs
element.one( "tabsactivate", function( event, ui ) {
- equal( event.originalEvent.type, "click", "originalEvent" );
- equal( ui.oldTab.length, 1, "oldTab length" );
- strictEqual( ui.oldTab[ 0 ], tabs[ 0 ], "oldTab" );
- equal( ui.oldPanel.length, 1, "oldPanel length" );
- strictEqual( ui.oldPanel[ 0 ], panels[ 0 ], "oldPanel" );
- equal( ui.newTab.length, 1, "newTab length" );
- strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
- equal( ui.newPanel.length, 1, "newPanel length" );
- strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
- state( element, 0, 1, 0 );
+ assert.equal( event.originalEvent.type, "click", "originalEvent" );
+ assert.equal( ui.oldTab.length, 1, "oldTab length" );
+ assert.strictEqual( ui.oldTab[ 0 ], tabs[ 0 ], "oldTab" );
+ assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+ assert.strictEqual( ui.oldPanel[ 0 ], panels[ 0 ], "oldPanel" );
+ assert.equal( ui.newTab.length, 1, "newTab length" );
+ assert.strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
+ assert.equal( ui.newPanel.length, 1, "newPanel length" );
+ assert.strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
+ state( assert, element, 0, 1, 0 );
} );
anchors.eq( 1 ).trigger( "click" );
- state( element, 0, 1, 0 );
+ state( assert, element, 0, 1, 0 );
// Collapsing
element.one( "tabsactivate", function( event, ui ) {
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.oldTab.length, 1, "oldTab length" );
- strictEqual( ui.oldTab[ 0 ], tabs[ 1 ], "oldTab" );
- equal( ui.oldPanel.length, 1, "oldPanel length" );
- strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
- equal( ui.newTab.length, 0, "newTab length" );
- equal( ui.newPanel.length, 0, "newPanel length" );
- state( element, 0, 0, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.oldTab.length, 1, "oldTab length" );
+ assert.strictEqual( ui.oldTab[ 0 ], tabs[ 1 ], "oldTab" );
+ assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+ assert.strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
+ assert.equal( ui.newTab.length, 0, "newTab length" );
+ assert.equal( ui.newPanel.length, 0, "newPanel length" );
+ state( assert, element, 0, 0, 0 );
} );
element.tabs( "option", "active", false );
- state( element, 0, 0, 0 );
+ state( assert, element, 0, 0, 0 );
// Prevent activation
element.one( "tabsbeforeactivate", function( event ) {
- ok( true, "tabsbeforeactivate" );
+ assert.ok( true, "tabsbeforeactivate" );
event.preventDefault();
} );
element.one( "tabsactivate", function() {
- ok( false, "tabsactivate" );
+ assert.ok( false, "tabsactivate" );
} );
element.tabs( "option", "active", 1 );
} );
-test( "beforeLoad", function() {
- expect( 32 );
+QUnit.test( "beforeLoad", function( assert ) {
+ assert.expect( 32 );
var tab, panelId, panel,
element = $( "#tabs2" );
@@ -196,20 +197,20 @@ test( "beforeLoad", function() {
panelId = tab.attr( "aria-controls" );
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- ok( "abort" in ui.jqXHR, "jqXHR" );
- ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- equal( ui.panel.html(), "", "panel html" );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.ok( "abort" in ui.jqXHR, "jqXHR" );
+ assert.ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( ui.panel.html(), "", "panel html" );
event.preventDefault();
- state( element, 0, 0, 1, 0, 0 );
+ state( assert, element, 0, 0, 1, 0, 0 );
} );
element.tabs( { active: 2 } );
- state( element, 0, 0, 1, 0, 0 );
- equal( panel.html(), "", "panel html after" );
+ state( assert, element, 0, 0, 1, 0, 0 );
+ assert.equal( panel.html(), "", "panel html after" );
element.tabs( "destroy" );
// .option()
@@ -218,21 +219,21 @@ test( "beforeLoad", function() {
panelId = tab.attr( "aria-controls" );
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- ok( "abort" in ui.jqXHR, "jqXHR" );
- ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- equal( ui.panel.html(), "", "panel html" );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.ok( "abort" in ui.jqXHR, "jqXHR" );
+ assert.ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( ui.panel.html(), "", "panel html" );
event.preventDefault();
- state( element, 1, 0, 0, 0, 0 );
+ state( assert, element, 1, 0, 0, 0, 0 );
} );
element.tabs();
element.tabs( "option", "active", 2 );
- state( element, 0, 0, 1, 0, 0 );
- equal( panel.html(), "", "panel html after" );
+ state( assert, element, 0, 0, 1, 0, 0 );
+ assert.equal( panel.html(), "", "panel html after" );
// Click, change panel content
element.one( "tabsbeforeload", function( event, ui ) {
@@ -240,26 +241,27 @@ test( "beforeLoad", function() {
panelId = tab.attr( "aria-controls" );
panel = $( "#" + panelId );
- equal( event.originalEvent.type, "click", "originalEvent" );
- ok( "abort" in ui.jqXHR, "jqXHR" );
- ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( event.originalEvent.type, "click", "originalEvent" );
+ assert.ok( "abort" in ui.jqXHR, "jqXHR" );
+ assert.ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
ui.panel.html( "testing
" );
event.preventDefault();
- state( element, 0, 0, 1, 0, 0 );
+ state( assert, element, 0, 0, 1, 0, 0 );
} );
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 3 ).trigger( "click" );
- state( element, 0, 0, 0, 1, 0 );
+ state( assert, element, 0, 0, 0, 1, 0 );
// .toLowerCase() is needed to convert to
in old IEs
- equal( panel.html().toLowerCase(), "
testing
", "panel html after" );
+ assert.equal( panel.html().toLowerCase(), "testing
", "panel html after" );
} );
-asyncTest( "load", function() {
- expect( 21 );
+QUnit.test( "load", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 21 );
var tab, panelId, panel,
element = $( "#tabs2" );
@@ -270,13 +272,13 @@ asyncTest( "load", function() {
panelId = tab.attr( "aria-controls" );
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- equal( ui.panel.find( "p" ).length, 1, "panel html" );
- state( element, 0, 0, 1, 0, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( ui.panel.find( "p" ).length, 1, "panel html" );
+ state( assert, element, 0, 0, 1, 0, 0 );
tabsload1();
} );
element.tabs( { active: 2 } );
@@ -289,13 +291,13 @@ asyncTest( "load", function() {
panelId = tab.attr( "aria-controls" );
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- equal( ui.panel.find( "p" ).length, 1, "panel html" );
- state( element, 0, 0, 0, 1, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( ui.panel.find( "p" ).length, 1, "panel html" );
+ state( assert, element, 0, 0, 0, 1, 0 );
tabsload2();
} );
element.tabs( "option", "active", 3 );
@@ -303,20 +305,20 @@ asyncTest( "load", function() {
function tabsload2() {
- // click, change panel content
+ // Click, change panel content
element.one( "tabsload", function( event, ui ) {
tab = element.find( ".ui-tabs-nav li" ).eq( 4 );
panelId = tab.attr( "aria-controls" );
panel = $( "#" + panelId );
- equal( event.originalEvent.type, "click", "originalEvent" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- equal( ui.panel.find( "p" ).length, 1, "panel html" );
- state( element, 0, 0, 0, 0, 1 );
- start();
+ assert.equal( event.originalEvent.type, "click", "originalEvent" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( ui.panel.find( "p" ).length, 1, "panel html" );
+ state( assert, element, 0, 0, 0, 0, 1 );
+ ready();
} );
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 4 ).trigger( "click" );
}
diff --git a/tests/unit/tabs/helper.js b/tests/unit/tabs/helper.js
index 8c102ec6084..b3fb1d6fd42 100644
--- a/tests/unit/tabs/helper.js
+++ b/tests/unit/tabs/helper.js
@@ -5,7 +5,7 @@ define( [
], function( $, helper ) {
return $.extend( helper, {
- disabled: function( tabs, state ) {
+ disabled: function( assert, tabs, state ) {
var expected, actual,
internalState = tabs.tabs( "option", "disabled" );
@@ -18,7 +18,7 @@ return $.extend( helper, {
} );
}
- expected = $.map( new Array( tabs.find ( ".ui-tabs-nav li" ).length ), function( _, index ) {
+ expected = $.map( new Array( tabs.find( ".ui-tabs-nav li" ).length ), function( _, index ) {
if ( typeof state === "boolean" ) {
return state ? 1 : 0;
} else {
@@ -37,25 +37,25 @@ return $.extend( helper, {
return 0;
}
- // mixed state - invalid
+ // Mixed state - invalid
return -1;
} ).get();
- deepEqual( tabs.tabs( "option", "disabled" ), state );
- deepEqual( actual, expected );
+ assert.deepEqual( tabs.tabs( "option", "disabled" ), state );
+ assert.deepEqual( actual, expected );
},
- equalHeight: function( tabs, height ) {
+ equalHeight: function( assert, tabs, height ) {
tabs.find( ".ui-tabs-panel" ).each( function() {
// Handle overly-precise values
var actualHeight = parseFloat( $( this ).outerHeight().toFixed( 1 ) );
- equal( actualHeight, height );
+ assert.equal( actualHeight, height );
} );
},
- state: function( tabs ) {
- var expected = $.makeArray( arguments ).slice( 1 ),
+ state: function( assert, tabs ) {
+ var expected = $.makeArray( arguments ).slice( 2 ),
actual = tabs.find( ".ui-tabs-nav li" ).map( function() {
var tab = $( this ),
panel = $( $.ui.tabs.prototype._sanitizeSelector(
@@ -69,9 +69,9 @@ return $.extend( helper, {
if ( !tabIsActive && !panelIsActive ) {
return 0;
}
- return -1; // mixed state - invalid
+ return -1; // Mixed state - invalid
} ).get();
- deepEqual( actual, expected );
+ assert.deepEqual( actual, expected );
}
} );
diff --git a/tests/unit/tabs/methods.js b/tests/unit/tabs/methods.js
index ef7c09ba78d..138f84fca61 100644
--- a/tests/unit/tabs/methods.js
+++ b/tests/unit/tabs/methods.js
@@ -1,16 +1,17 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/tabs"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
var disabled = testHelper.disabled,
state = testHelper.state;
-module( "tabs: methods" );
+QUnit.module( "tabs: methods" );
-test( "destroy", function( assert ) {
- expect( 2 );
+QUnit.test( "destroy", function( assert ) {
+ assert.expect( 2 );
assert.domEqual( "#tabs1", function() {
$( "#tabs1" ).tabs().tabs( "destroy" );
} );
@@ -19,15 +20,16 @@ test( "destroy", function( assert ) {
} );
} );
-asyncTest( "destroy - ajax", function( assert ) {
- expect( 1 );
+QUnit.test( "destroy - ajax", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 1 );
assert.domEqual( "#tabs2", function( done ) {
var element = $( "#tabs2" ).tabs( {
load: function() {
setTimeout( function() {
element.tabs( "destroy" );
done();
- start();
+ ready();
} );
}
} );
@@ -35,108 +37,108 @@ asyncTest( "destroy - ajax", function( assert ) {
} );
} );
-test( "enable", function() {
- expect( 8 );
+QUnit.test( "enable", function( assert ) {
+ assert.expect( 8 );
var element = $( "#tabs1" ).tabs( { disabled: true } );
- disabled( element, true );
+ disabled( assert, element, true );
element.tabs( "enable" );
- disabled( element, false );
+ disabled( assert, element, false );
element.tabs( "destroy" );
element.tabs( { disabled: [ 0, 1 ] } );
- disabled( element, [ 0, 1 ] );
+ disabled( assert, element, [ 0, 1 ] );
element.tabs( "enable" );
- disabled( element, false );
+ disabled( assert, element, false );
} );
-test( "enable( index )", function() {
- expect( 10 );
+QUnit.test( "enable( index )", function( assert ) {
+ assert.expect( 10 );
var element = $( "#tabs1" ).tabs( { disabled: true } );
- disabled( element, true );
+ disabled( assert, element, true );
// fully disabled -> partially disabled
element.tabs( "enable", 1 );
- disabled( element, [ 0, 2 ] );
+ disabled( assert, element, [ 0, 2 ] );
// partially disabled -> partially disabled
element.tabs( "enable", 2 );
- disabled( element, [ 0 ] );
+ disabled( assert, element, [ 0 ] );
// already enabled tab, no change
element.tabs( "enable", 2 );
- disabled( element, [ 0 ] );
+ disabled( assert, element, [ 0 ] );
// partially disabled -> fully enabled
element.tabs( "enable", 0 );
- disabled( element, false );
+ disabled( assert, element, false );
} );
-test( "disable", function() {
- expect( 8 );
+QUnit.test( "disable", function( assert ) {
+ assert.expect( 8 );
var element = $( "#tabs1" ).tabs( { disabled: false } );
- disabled( element, false );
+ disabled( assert, element, false );
element.tabs( "disable" );
- disabled( element, true );
+ disabled( assert, element, true );
element.tabs( "destroy" );
element.tabs( { disabled: [ 0, 1 ] } );
- disabled( element, [ 0, 1 ] );
+ disabled( assert, element, [ 0, 1 ] );
element.tabs( "disable" );
- disabled( element, true );
+ disabled( assert, element, true );
} );
-test( "disable( index )", function() {
- expect( 10 );
+QUnit.test( "disable( index )", function( assert ) {
+ assert.expect( 10 );
var element = $( "#tabs1" ).tabs( { disabled: false } );
- disabled( element, false );
+ disabled( assert, element, false );
// fully enabled -> partially disabled
element.tabs( "disable", 1 );
- disabled( element, [ 1 ] );
+ disabled( assert, element, [ 1 ] );
// partially disabled -> partially disabled
element.tabs( "disable", 2 );
- disabled( element, [ 1, 2 ] );
+ disabled( assert, element, [ 1, 2 ] );
// already disabled tab, no change
element.tabs( "disable", 2 );
- disabled( element, [ 1, 2 ] );
+ disabled( assert, element, [ 1, 2 ] );
// partially disabled -> fully disabled
element.tabs( "disable", 0 );
- disabled( element, true );
+ disabled( assert, element, true );
} );
-test( "refresh", function() {
- expect( 27 );
+QUnit.test( "refresh", function( assert ) {
+ assert.expect( 27 );
var element = $( "#tabs1" ).tabs();
- state( element, 1, 0, 0 );
- disabled( element, false );
+ state( assert, element, 1, 0, 0 );
+ disabled( assert, element, false );
// Disable tab via markup
element.find( ".ui-tabs-nav li" ).eq( 1 ).addClass( "ui-state-disabled" );
element.tabs( "refresh" );
- state( element, 1, 0, 0 );
- disabled( element, [ 1 ] );
+ state( assert, element, 1, 0, 0 );
+ disabled( assert, element, [ 1 ] );
// Add remote tab
element.find( ".ui-tabs-nav" ).append( "new" );
element.tabs( "refresh" );
- state( element, 1, 0, 0, 0 );
- disabled( element, [ 1 ] );
- equal( element.find( "#" + $( "#newTab" ).attr( "aria-controls" ) ).length, 1,
+ state( assert, element, 1, 0, 0, 0 );
+ disabled( assert, element, [ 1 ] );
+ assert.equal( element.find( "#" + $( "#newTab" ).attr( "aria-controls" ) ).length, 1,
"panel added for remote tab" );
// Remove all tabs
element.find( ".ui-tabs-nav li, .ui-tabs-panel" ).remove();
element.tabs( "refresh" );
- state( element );
- equal( element.tabs( "option", "active" ), false, "no active tab" );
+ state( assert, element );
+ assert.equal( element.tabs( "option", "active" ), false, "no active tab" );
// Add tabs
element.find( ".ui-tabs-nav" )
@@ -150,45 +152,45 @@ test( "refresh", function() {
.append( "new 4
" )
.append( "new 5
" );
element.tabs( "refresh" );
- state( element, 0, 0, 0, 0 );
- disabled( element, [ 0 ] );
+ state( assert, element, 0, 0, 0, 0 );
+ disabled( assert, element, [ 0 ] );
// Activate third tab
element.tabs( "option", "active", 2 );
- state( element, 0, 0, 1, 0 );
- disabled( element, [ 0 ] );
+ state( assert, element, 0, 0, 1, 0 );
+ disabled( assert, element, [ 0 ] );
// Remove fourth tab, third tab should stay active
element.find( ".ui-tabs-nav li" ).eq( 3 ).remove();
element.find( ".ui-tabs-panel" ).eq( 3 ).remove();
element.tabs( "refresh" );
- state( element, 0, 0, 1 );
- disabled( element, [ 0 ] );
+ state( assert, element, 0, 0, 1 );
+ disabled( assert, element, [ 0 ] );
// Remove third (active) tab, second tab should become active
element.find( ".ui-tabs-nav li" ).eq( 2 ).remove();
element.find( ".ui-tabs-panel" ).eq( 2 ).remove();
element.tabs( "refresh" );
- state( element, 0, 1 );
- disabled( element, [ 0 ] );
+ state( assert, element, 0, 1 );
+ disabled( assert, element, [ 0 ] );
// Remove first tab, previously active tab (now first) should stay active
element.find( ".ui-tabs-nav li" ).eq( 0 ).remove();
element.find( ".ui-tabs-panel" ).eq( 0 ).remove();
element.tabs( "refresh" );
- state( element, 1 );
- disabled( element, false );
+ state( assert, element, 1 );
+ disabled( assert, element, false );
} );
-test( "refresh - looping", function() {
- expect( 6 );
+QUnit.test( "refresh - looping", function( assert ) {
+ assert.expect( 6 );
var element = $( "#tabs1" ).tabs( {
disabled: [ 0 ],
active: 1
} );
- state( element, 0, 1, 0 );
- disabled( element, [ 0 ] );
+ state( assert, element, 0, 1, 0 );
+ disabled( assert, element, [ 0 ] );
// Remove active, jump to previous
// previous is disabled, just back one more
@@ -196,12 +198,13 @@ test( "refresh - looping", function() {
// activate last tab
element.find( ".ui-tabs-nav li" ).eq( 2 ).remove();
element.tabs( "refresh" );
- state( element, 0, 1 );
- disabled( element, [ 0 ] );
+ state( assert, element, 0, 1 );
+ disabled( assert, element, [ 0 ] );
} );
-asyncTest( "load", function() {
- expect( 30 );
+QUnit.test( "load", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 30 );
var element = $( "#tabs2" ).tabs();
@@ -212,12 +215,12 @@ asyncTest( "load", function() {
panelId = tab.attr( "aria-controls" ),
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- state( element, 1, 0, 0, 0, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ state( assert, element, 1, 0, 0, 0, 0 );
} );
element.one( "tabsload", function( event, ui ) {
@@ -228,30 +231,30 @@ asyncTest( "load", function() {
panelId = tab.attr( "aria-controls" ),
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( uiTab.length, 1, "tab length" );
- strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
- equal( uiPanel.length, 1, "panel length" );
- strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
- equal( uiPanel.find( "p" ).length, 1, "panel html" );
- state( element, 1, 0, 0, 0, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( uiTab.length, 1, "tab length" );
+ assert.strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( uiPanel.length, 1, "panel length" );
+ assert.strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
+ assert.equal( uiPanel.find( "p" ).length, 1, "panel html" );
+ state( assert, element, 1, 0, 0, 0, 0 );
setTimeout( tabsload1 );
} );
element.tabs( "load", 3 );
- state( element, 1, 0, 0, 0, 0 );
+ state( assert, element, 1, 0, 0, 0, 0 );
function tabsload1() {
// no need to test details of event (tested in events tests)
element.one( "tabsbeforeload", function() {
- ok( true, "tabsbeforeload invoked" );
+ assert.ok( true, "tabsbeforeload invoked" );
} );
element.one( "tabsload", function() {
- ok( true, "tabsload invoked" );
+ assert.ok( true, "tabsload invoked" );
setTimeout( tabsload2 );
} );
element.tabs( "option", "active", 3 );
- state( element, 0, 0, 0, 1, 0 );
+ state( assert, element, 0, 0, 0, 1, 0 );
}
function tabsload2() {
@@ -262,12 +265,12 @@ asyncTest( "load", function() {
panelId = tab.attr( "aria-controls" ),
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( ui.tab.length, 1, "tab length" );
- strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
- equal( ui.panel.length, 1, "panel length" );
- strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
- state( element, 0, 0, 0, 1, 0 );
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( ui.tab.length, 1, "tab length" );
+ assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( ui.panel.length, 1, "panel length" );
+ assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+ state( assert, element, 0, 0, 0, 1, 0 );
} );
element.one( "tabsload", function( event, ui ) {
@@ -278,25 +281,25 @@ asyncTest( "load", function() {
panelId = tab.attr( "aria-controls" ),
panel = $( "#" + panelId );
- ok( !( "originalEvent" in event ), "originalEvent" );
- equal( uiTab.length, 1, "tab length" );
- strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
- equal( uiPanel.length, 1, "panel length" );
- strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
- state( element, 0, 0, 0, 1, 0 );
- start();
+ assert.ok( !( "originalEvent" in event ), "originalEvent" );
+ assert.equal( uiTab.length, 1, "tab length" );
+ assert.strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
+ assert.equal( uiPanel.length, 1, "panel length" );
+ assert.strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
+ state( assert, element, 0, 0, 0, 1, 0 );
+ ready();
} );
element.tabs( "load", 3 );
- state( element, 0, 0, 0, 1, 0 );
+ state( assert, element, 0, 0, 0, 1, 0 );
}
} );
-test( "widget", function() {
- expect( 2 );
+QUnit.test( "widget", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tabs1" ).tabs(),
widgetElement = element.tabs( "widget" );
- equal( widgetElement.length, 1, "one element" );
- strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" );
+ assert.equal( widgetElement.length, 1, "one element" );
+ assert.strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" );
} );
} );
diff --git a/tests/unit/tabs/options.js b/tests/unit/tabs/options.js
index 4092cfcf8fc..3735038434d 100644
--- a/tests/unit/tabs/options.js
+++ b/tests/unit/tabs/options.js
@@ -1,118 +1,119 @@
define( [
+ "qunit",
"jquery",
"./helper",
"ui/widgets/tabs"
-], function( $, testHelper ) {
+], function( QUnit, $, testHelper ) {
var disabled = testHelper.disabled,
equalHeight = testHelper.equalHeight,
state = testHelper.state;
-module( "tabs: options" );
+QUnit.module( "tabs: options" );
-test( "{ active: default }", function() {
- expect( 6 );
+QUnit.test( "{ active: default }", function( assert ) {
+ assert.expect( 6 );
var element = $( "#tabs1" ).tabs();
- equal( element.tabs( "option", "active" ), 0, "should be 0 by default" );
- state( element, 1, 0, 0 );
+ assert.equal( element.tabs( "option", "active" ), 0, "should be 0 by default" );
+ state( assert, element, 1, 0, 0 );
element.tabs( "destroy" );
location.hash = "#fragment-3";
element = $( "#tabs1" ).tabs();
- equal( element.tabs( "option", "active" ), 2, "should be 2 based on URL" );
- state( element, 0, 0, 1 );
+ assert.equal( element.tabs( "option", "active" ), 2, "should be 2 based on URL" );
+ state( assert, element, 0, 0, 1 );
element.tabs( "destroy" );
location.hash = "#custom-id";
element = $( "#tabs2" ).tabs();
- equal( element.tabs( "option", "active" ), 3, "should be 3 based on URL" );
- state( element, 0, 0, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 3, "should be 3 based on URL" );
+ state( assert, element, 0, 0, 0, 1, 0 );
element.tabs( "destroy" );
location.hash = "#";
} );
-test( "{ active: false }", function() {
- expect( 7 );
+QUnit.test( "{ active: false }", function( assert ) {
+ assert.expect( 7 );
var element = $( "#tabs1" ).tabs( {
active: false,
collapsible: true
} );
- state( element, 0, 0, 0 );
- equal( element.find( ".ui-tabs-nav .ui-state-active" ).length, 0, "no tabs selected" );
- strictEqual( element.tabs( "option", "active" ), false );
+ state( assert, element, 0, 0, 0 );
+ assert.equal( element.find( ".ui-tabs-nav .ui-state-active" ).length, 0, "no tabs selected" );
+ assert.strictEqual( element.tabs( "option", "active" ), false );
element.tabs( "option", "collapsible", false );
- state( element, 1, 0, 0 );
- equal( element.tabs( "option", "active" ), 0 );
+ state( assert, element, 1, 0, 0 );
+ assert.equal( element.tabs( "option", "active" ), 0 );
element.tabs( "destroy" );
element.tabs( {
active: false
} );
- state( element, 1, 0, 0 );
- strictEqual( element.tabs( "option", "active" ), 0 );
+ state( assert, element, 1, 0, 0 );
+ assert.strictEqual( element.tabs( "option", "active" ), 0 );
} );
-test( "{ active: Number }", function() {
- expect( 8 );
+QUnit.test( "{ active: Number }", function( assert ) {
+ assert.expect( 8 );
var element = $( "#tabs1" ).tabs( {
active: 2
} );
- equal( element.tabs( "option", "active" ), 2 );
- state( element, 0, 0, 1 );
+ assert.equal( element.tabs( "option", "active" ), 2 );
+ state( assert, element, 0, 0, 1 );
element.tabs( "option", "active", 0 );
- equal( element.tabs( "option", "active" ), 0 );
- state( element, 1, 0, 0 );
+ assert.equal( element.tabs( "option", "active" ), 0 );
+ state( assert, element, 1, 0, 0 );
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "click" );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
element.tabs( "option", "active", 10 );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
} );
-test( "{ active: -Number }", function() {
- expect( 8 );
+QUnit.test( "{ active: -Number }", function( assert ) {
+ assert.expect( 8 );
var element = $( "#tabs1" ).tabs( {
active: -1
} );
- equal( element.tabs( "option", "active" ), 2 );
- state( element, 0, 0, 1 );
+ assert.equal( element.tabs( "option", "active" ), 2 );
+ state( assert, element, 0, 0, 1 );
element.tabs( "option", "active", -2 );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
element.tabs( "option", "active", -10 );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
element.tabs( "option", "active", -3 );
- equal( element.tabs( "option", "active" ), 0 );
- state( element, 1, 0, 0 );
+ assert.equal( element.tabs( "option", "active" ), 0 );
+ state( assert, element, 1, 0, 0 );
} );
-test( "active - mismatched tab/panel order", function() {
- expect( 3 );
+QUnit.test( "active - mismatched tab/panel order", function( assert ) {
+ assert.expect( 3 );
location.hash = "#tabs7-2";
var element = $( "#tabs7" ).tabs();
- equal( element.tabs( "option", "active" ), 1, "should be 1 based on URL" );
- state( element, 0, 1 );
+ assert.equal( element.tabs( "option", "active" ), 1, "should be 1 based on URL" );
+ state( assert, element, 0, 1 );
element.tabs( "option", "active", 0 );
- state( element, 1, 0 );
+ state( assert, element, 1, 0 );
location.hash = "#";
} );
-test( "collapsible", function( assert ) {
- expect( 13 );
+QUnit.test( "collapsible", function( assert ) {
+ assert.expect( 13 );
var element = $( "#tabs1" ).tabs( {
active: 1,
@@ -120,16 +121,16 @@ test( "collapsible", function( assert ) {
} );
assert.hasClasses( element, "ui-tabs-collapsible" );
element.tabs( "option", "active", false );
- equal( element.tabs( "option", "active" ), false );
- state( element, 0, 0, 0 );
+ assert.equal( element.tabs( "option", "active" ), false );
+ state( assert, element, 0, 0, 0 );
element.tabs( "option", "active", 1 );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
element.find( ".ui-state-active .ui-tabs-anchor" ).trigger( "click" );
- equal( element.tabs( "option", "active" ), false );
- state( element, 0, 0, 0 );
+ assert.equal( element.tabs( "option", "active" ), false );
+ state( assert, element, 0, 0, 0 );
element.tabs( "option", "collapsible", false );
assert.lacksClasses( element, "ui-tabs-collapsible" );
@@ -143,132 +144,132 @@ test( "collapsible", function( assert ) {
collapsible: false
} );
element.tabs( "option", "active", false );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
element.find( ".ui-state-active .ui-tabs-anchor" ).eq( 1 ).trigger( "click" );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
} );
-test( "disabled", function( assert ) {
- expect( 23 );
+QUnit.test( "disabled", function( assert ) {
+ assert.expect( 23 );
// Fully enabled by default
var event,
element = $( "#tabs1" ).tabs();
- disabled( element, false );
+ disabled( assert, element, false );
assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
assert.lacksClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
- ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+ assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
// Disable single tab
element.tabs( "option", "disabled", [ 1 ] );
- disabled( element, [ 1 ] );
+ disabled( assert, element, [ 1 ] );
assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
assert.lacksClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
- ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+ assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
// Disabled active tab
element.tabs( "option", "disabled", [ 0, 1 ] );
- disabled( element, [ 0, 1 ] );
+ disabled( assert, element, [ 0, 1 ] );
assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
assert.lacksClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
- ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+ assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
// Disable all tabs
element.tabs( "option", "disabled", [ 0, 1, 2 ] );
- disabled( element, true );
+ disabled( assert, element, true );
assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
assert.hasClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
- ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+ assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
event = $.Event( "click" );
element.find( ".ui-tabs-anchor" ).eq( 0 ).trigger( event );
- ok( event.isDefaultPrevented(), "click is prevented for disabled tab" );
+ assert.ok( event.isDefaultPrevented(), "click is prevented for disabled tab" );
// Enable all tabs
element.tabs( "option", "disabled", [] );
- disabled( element, false );
+ disabled( assert, element, false );
} );
-test( "{ event: null }", function() {
- expect( 5 );
+QUnit.test( "{ event: null }", function( assert ) {
+ assert.expect( 5 );
var element = $( "#tabs1" ).tabs( {
event: null
} );
- state( element, 1, 0, 0 );
+ state( assert, element, 1, 0, 0 );
element.tabs( "option", "active", 1 );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
// Ensure default click handler isn't bound
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 2 ).trigger( "click" );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
} );
-test( "{ event: custom }", function() {
- expect( 11 );
+QUnit.test( "{ event: custom }", function( assert ) {
+ assert.expect( 11 );
var element = $( "#tabs1" ).tabs( {
event: "custom1 custom2"
} );
- state( element, 1, 0, 0 );
+ state( assert, element, 1, 0, 0 );
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "custom1" );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
// Ensure default click handler isn't bound
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 2 ).trigger( "click" );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 2 ).trigger( "custom2" );
- equal( element.tabs( "option", "active" ), 2 );
- state( element, 0, 0, 1 );
+ assert.equal( element.tabs( "option", "active" ), 2 );
+ state( assert, element, 0, 0, 1 );
element.tabs( "option", "event", "custom3" );
// Ensure old event handlers are unbound
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "custom1" );
- equal( element.tabs( "option", "active" ), 2 );
- state( element, 0, 0, 1 );
+ assert.equal( element.tabs( "option", "active" ), 2 );
+ state( assert, element, 0, 0, 1 );
element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "custom3" );
- equal( element.tabs( "option", "active" ), 1 );
- state( element, 0, 1, 0 );
+ assert.equal( element.tabs( "option", "active" ), 1 );
+ state( assert, element, 0, 1, 0 );
} );
-test( "{ heightStyle: 'auto' }", function() {
- expect( 2 );
+QUnit.test( "{ heightStyle: 'auto' }", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tabs8" ).tabs( { heightStyle: "auto" } );
- equalHeight( element, 45 );
+ equalHeight( assert, element, 45 );
} );
-test( "{ heightStyle: 'content' }", function() {
- expect( 2 );
+QUnit.test( "{ heightStyle: 'content' }", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tabs8" ).tabs( { heightStyle: "content" } ),
sizes = element.find( ".ui-tabs-panel" ).map( function() {
return $( this ).height();
} ).get();
- equal( sizes[ 0 ], 45 );
- equal( sizes[ 1 ], 15 );
+ assert.equal( sizes[ 0 ], 45 );
+ assert.equal( sizes[ 1 ], 15 );
} );
-test( "{ heightStyle: 'fill' }", function() {
- expect( 4 );
+QUnit.test( "{ heightStyle: 'fill' }", function( assert ) {
+ assert.expect( 4 );
$( "#tabs8Wrapper" ).height( 500 );
var element = $( "#tabs8" ).tabs( { heightStyle: "fill" } );
- equalHeight( element, 485 );
+ equalHeight( assert, element, 485 );
element.tabs( "destroy" );
element = $( "#tabs8" ).css( {
@@ -276,11 +277,11 @@ test( "{ heightStyle: 'fill' }", function() {
"padding": "1px 0"
} );
element.tabs( { heightStyle: "fill" } );
- equalHeight( element, 481 );
+ equalHeight( assert, element, 481 );
} );
-test( "{ heightStyle: 'fill' } with sibling", function() {
- expect( 2 );
+QUnit.test( "{ heightStyle: 'fill' } with sibling", function( assert ) {
+ assert.expect( 2 );
$( "#tabs8Wrapper" ).height( 500 );
$( "Lorem Ipsum
" )
.css( {
@@ -290,11 +291,11 @@ test( "{ heightStyle: 'fill' } with sibling", function() {
} )
.prependTo( "#tabs8Wrapper" );
var element = $( "#tabs8" ).tabs( { heightStyle: "fill" } );
- equalHeight( element, 385 );
+ equalHeight( assert, element, 385 );
} );
-test( "{ heightStyle: 'fill' } with multiple siblings", function() {
- expect( 2 );
+QUnit.test( "{ heightStyle: 'fill' } with multiple siblings", function( assert ) {
+ assert.expect( 2 );
$( "#tabs8Wrapper" ).height( 500 );
$( "Lorem Ipsum
" )
.css( {
@@ -319,11 +320,11 @@ test( "{ heightStyle: 'fill' } with multiple siblings", function() {
} )
.prependTo( "#tabs8Wrapper" );
var element = $( "#tabs8" ).tabs( { heightStyle: "fill" } );
- equalHeight( element, 335 );
+ equalHeight( assert, element, 335 );
} );
-test( "hide and show: false", function() {
- expect( 3 );
+QUnit.test( "hide and show: false", function( assert ) {
+ assert.expect( 3 );
var element = $( "#tabs1" ).tabs( {
show: false,
hide: false
@@ -331,20 +332,21 @@ test( "hide and show: false", function() {
widget = element.tabs( "instance" ),
panels = element.find( ".ui-tabs-panel" );
widget._show = function() {
- ok( false, "_show() called" );
+ assert.ok( false, "_show() called" );
};
widget._hide = function() {
- ok( false, "_hide() called" );
+ assert.ok( false, "_hide() called" );
};
- ok( panels.eq( 0 ).is( ":visible" ), "first panel visible" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel visible" );
element.tabs( "option", "active", 1 );
- ok( panels.eq( 0 ).is( ":hidden" ), "first panel hidden" );
- ok( panels.eq( 1 ).is( ":visible" ), "second panel visible" );
+ assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel hidden" );
+ assert.ok( panels.eq( 1 ).is( ":visible" ), "second panel visible" );
} );
-asyncTest( "hide and show - animation", function() {
- expect( 5 );
+QUnit.test( "hide and show - animation", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 5 );
var element = $( "#tabs1" ).tabs( {
show: "drop",
hide: 2000
@@ -352,22 +354,22 @@ asyncTest( "hide and show - animation", function() {
widget = element.tabs( "instance" ),
panels = element.find( ".ui-tabs-panel" );
widget._show = function( element, options, callback ) {
- strictEqual( element[ 0 ], panels[ 1 ], "correct element in _show()" );
- equal( options, "drop", "correct options in _show()" );
+ assert.strictEqual( element[ 0 ], panels[ 1 ], "correct element in _show()" );
+ assert.equal( options, "drop", "correct options in _show()" );
setTimeout( function() {
callback();
} );
};
widget._hide = function( element, options, callback ) {
- strictEqual( element[ 0 ], panels[ 0 ], "correct element in _hide()" );
- equal( options, 2000, "correct options in _hide()" );
+ assert.strictEqual( element[ 0 ], panels[ 0 ], "correct element in _hide()" );
+ assert.equal( options, 2000, "correct options in _hide()" );
setTimeout( function() {
callback();
- start();
+ ready();
} );
};
- ok( panels.eq( 0 ).is( ":visible" ), "first panel visible" );
+ assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel visible" );
element.tabs( "option", "active", 1 );
} );
From 92f122d5b1c1eaa77ae0ab3af8bf68bf268e300d Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Wed, 6 Apr 2016 19:29:12 +0530
Subject: [PATCH 23/26] Tooltip: Shift to use no globals
---
tests/unit/tooltip/core.js | 128 ++++++++++++++++---------------
tests/unit/tooltip/deprecated.js | 9 ++-
tests/unit/tooltip/events.js | 33 ++++----
tests/unit/tooltip/methods.js | 67 ++++++++--------
tests/unit/tooltip/options.js | 107 +++++++++++++-------------
5 files changed, 177 insertions(+), 167 deletions(-)
diff --git a/tests/unit/tooltip/core.js b/tests/unit/tooltip/core.js
index 0dfdc582537..2de37097af1 100644
--- a/tests/unit/tooltip/core.js
+++ b/tests/unit/tooltip/core.js
@@ -1,83 +1,84 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/tooltip"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "tooltip: core" );
+QUnit.module( "tooltip: core" );
-test( "markup structure", function( assert ) {
- expect( 7 );
+QUnit.test( "markup structure", function( assert ) {
+ assert.expect( 7 );
var element = $( "#tooltipped1" ).tooltip(),
tooltip = $( ".ui-tooltip" );
- equal( element.attr( "aria-describedby" ), undefined, "no aria-describedby on init" );
- equal( tooltip.length, 0, "no tooltip on init" );
+ assert.equal( element.attr( "aria-describedby" ), undefined, "no aria-describedby on init" );
+ assert.equal( tooltip.length, 0, "no tooltip on init" );
element.tooltip( "open" );
tooltip = $( "#" + element.data( "ui-tooltip-id" ) );
- equal( tooltip.length, 1, "tooltip exists" );
- equal( element.attr( "aria-describedby" ), tooltip.attr( "id" ), "aria-describedby" );
+ assert.equal( tooltip.length, 1, "tooltip exists" );
+ assert.equal( element.attr( "aria-describedby" ), tooltip.attr( "id" ), "aria-describedby" );
assert.hasClasses( tooltip, "ui-tooltip ui-widget ui-widget-content ui-widget-shadow" );
- equal( tooltip.length, 1, ".ui-tooltip exists" );
- equal( tooltip.find( ".ui-tooltip-content" ).length, 1,
+ assert.equal( tooltip.length, 1, ".ui-tooltip exists" );
+ assert.equal( tooltip.find( ".ui-tooltip-content" ).length, 1,
".ui-tooltip-content exists" );
} );
-test( "accessibility", function() {
- expect( 15 );
+QUnit.test( "accessibility", function( assert ) {
+ assert.expect( 15 );
var tooltipId, tooltip,
element = $( "#multiple-describedby" ).tooltip(),
liveRegion = element.tooltip( "instance" ).liveRegion;
- equal( liveRegion.find( ">div" ).length, 0 );
- equal( liveRegion.attr( "role" ), "log" );
- equal( liveRegion.attr( "aria-live" ), "assertive" );
- equal( liveRegion.attr( "aria-relevant" ), "additions" );
+ assert.equal( liveRegion.find( ">div" ).length, 0 );
+ assert.equal( liveRegion.attr( "role" ), "log" );
+ assert.equal( liveRegion.attr( "aria-live" ), "assertive" );
+ assert.equal( liveRegion.attr( "aria-relevant" ), "additions" );
element.tooltip( "open" );
tooltipId = element.data( "ui-tooltip-id" );
tooltip = $( "#" + tooltipId );
- equal( tooltip.attr( "role" ), "tooltip", "role" );
- equal( element.attr( "aria-describedby" ), "fixture-span " + tooltipId,
+ assert.equal( tooltip.attr( "role" ), "tooltip", "role" );
+ assert.equal( element.attr( "aria-describedby" ), "fixture-span " + tooltipId,
"multiple describedby when open" );
- equal( element.attr( "title" ), null, "no title when open" );
- equal( liveRegion.children().length, 1 );
- equal( liveRegion.children().last().html(), "..." );
+ assert.equal( element.attr( "title" ), null, "no title when open" );
+ assert.equal( liveRegion.children().length, 1 );
+ assert.equal( liveRegion.children().last().html(), "..." );
element.tooltip( "close" );
- equal( element.attr( "aria-describedby" ), "fixture-span",
+ assert.equal( element.attr( "aria-describedby" ), "fixture-span",
"correct describedby when closed" );
- equal( element.attr( "title" ), "...", "title restored when closed" );
+ assert.equal( element.attr( "title" ), "...", "title restored when closed" );
element.tooltip( "open" );
- equal( liveRegion.children().length, 2,
+ assert.equal( liveRegion.children().length, 2,
"After the second tooltip show, there should be two children" );
- equal( liveRegion.children().filter( ":visible" ).length, 1,
+ assert.equal( liveRegion.children().filter( ":visible" ).length, 1,
"Only one of the children should be visible" );
- ok( liveRegion.children().last().is( ":visible" ),
+ assert.ok( liveRegion.children().last().is( ":visible" ),
"Only the last child should be visible" );
element.tooltip( "close" );
element.tooltip( "destroy" );
- equal( liveRegion.parent().length, 0,
+ assert.equal( liveRegion.parent().length, 0,
"Tooltip liveregion element should be removed" );
} );
-test( "delegated removal", function() {
- expect( 2 );
+QUnit.test( "delegated removal", function( assert ) {
+ assert.expect( 2 );
var container = $( "#contains-tooltipped" ).tooltip(),
element = $( "#contained-tooltipped" );
element.trigger( "mouseover" );
- equal( $( ".ui-tooltip" ).length, 1 );
+ assert.equal( $( ".ui-tooltip" ).length, 1 );
container.empty();
- equal( $( ".ui-tooltip" ).length, 0 );
+ assert.equal( $( ".ui-tooltip" ).length, 0 );
} );
-test( "nested tooltips", function() {
- expect( 2 );
+QUnit.test( "nested tooltips", function( assert ) {
+ assert.expect( 2 );
var child = $( "#contained-tooltipped" ),
parent = $( "#contains-tooltipped" ).tooltip( {
@@ -86,15 +87,15 @@ test( "nested tooltips", function() {
} );
parent.trigger( "mouseover" );
- equal( $( ".ui-tooltip:visible" ).text(), "parent" );
+ assert.equal( $( ".ui-tooltip:visible" ).text(), "parent" );
child.trigger( "mouseover" );
- equal( $( ".ui-tooltip" ).text(), "child" );
+ assert.equal( $( ".ui-tooltip" ).text(), "child" );
} );
// #8742
-test( "form containing an input with name title", function() {
- expect( 4 );
+QUnit.test( "form containing an input with name title", function( assert ) {
+ assert.expect( 4 );
var form = $( "#tooltip-form" ).tooltip( {
show: null,
@@ -102,33 +103,34 @@ test( "form containing an input with name title", function() {
} ),
input = form.find( "[name=title]" );
- equal( $( ".ui-tooltip" ).length, 0, "no tooltips on init" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "no tooltips on init" );
input.trigger( "mouseover" );
- equal( $( ".ui-tooltip" ).length, 1, "tooltip for input" );
+ assert.equal( $( ".ui-tooltip" ).length, 1, "tooltip for input" );
input.trigger( "mouseleave" );
- equal( $( ".ui-tooltip" ).length, 0, "tooltip for input closed" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "tooltip for input closed" );
form.trigger( "mouseover" );
- equal( $( ".ui-tooltip" ).length, 0, "no tooltip for form" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "no tooltip for form" );
} );
-test( "tooltip on .ui-state-disabled element", function() {
- expect( 2 );
+QUnit.test( "tooltip on .ui-state-disabled element", function( assert ) {
+ assert.expect( 2 );
var container = $( "#contains-tooltipped" ).tooltip(),
element = $( "#contained-tooltipped" ).addClass( "ui-state-disabled" );
element.trigger( "mouseover" );
- equal( $( ".ui-tooltip" ).length, 1 );
+ assert.equal( $( ".ui-tooltip" ).length, 1 );
container.empty();
- equal( $( ".ui-tooltip" ).length, 0 );
+ assert.equal( $( ".ui-tooltip" ).length, 0 );
} );
// http://bugs.jqueryui.com/ticket/8740
-asyncTest( "programmatic focus with async content", function() {
- expect( 2 );
+QUnit.test( "programmatic focus with async content", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 2 );
var element = $( "#tooltipped1" ).tooltip( {
content: function( response ) {
setTimeout( function() {
@@ -138,11 +140,11 @@ asyncTest( "programmatic focus with async content", function() {
} );
element.on( "tooltipopen", function( event ) {
- deepEqual( event.originalEvent.type, "focusin" );
+ assert.deepEqual( event.originalEvent.type, "focusin" );
element.on( "tooltipclose", function( event ) {
- deepEqual( event.originalEvent.type, "focusout" );
- start();
+ assert.deepEqual( event.originalEvent.type, "focusout" );
+ ready();
} );
setTimeout( function() {
@@ -153,8 +155,9 @@ asyncTest( "programmatic focus with async content", function() {
element.trigger( "focus" );
} );
-asyncTest( "destroy during hide animation; only one close event", function() {
- expect( 1 );
+QUnit.test( "destroy during hide animation; only one close event", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 1 );
var element = $( "#tooltipped1" ).tooltip( {
show: false,
@@ -162,20 +165,21 @@ asyncTest( "destroy during hide animation; only one close event", function() {
} );
element.on( "tooltipclose", function() {
- ok( true, "tooltip closed" );
+ assert.ok( true, "tooltip closed" );
} );
element.tooltip( "open" );
element.tooltip( "close" );
setTimeout( function() {
element.tooltip( "destroy" );
- start();
+ ready();
} );
} );
// http://bugs.jqueryui.com/ticket/10602
-asyncTest( "multiple active delegated tooltips", function() {
- expect( 1 );
+QUnit.test( "multiple active delegated tooltips", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 1 );
var anchor = $( "#tooltipped1" ),
input = anchor.next(),
@@ -209,21 +213,21 @@ asyncTest( "multiple active delegated tooltips", function() {
function step4() {
anchor.simulate( "mouseout" );
- deepEqual( actions, [
+ assert.deepEqual( actions, [
"open:anchortitle",
"open:inputtitle",
"close:inputtitle",
"close:anchortitle"
], "Both tooltips open and close" );
- start();
+ ready();
}
step1();
} );
// http://bugs.jqueryui.com/ticket/11272
-test( "remove conflicting attributes from live region", function() {
- expect( 2 );
+QUnit.test( "remove conflicting attributes from live region", function( assert ) {
+ assert.expect( 2 );
var element = $(
"" +
@@ -237,9 +241,9 @@ test( "remove conflicting attributes from live region", function() {
.tooltip( {
content: element,
open: function() {
- equal( $( ".ui-helper-hidden-accessible [name]" ).length, 0,
+ assert.equal( $( ".ui-helper-hidden-accessible [name]" ).length, 0,
"no name attributes within live region" );
- equal( $( ".ui-helper-hidden-accessible [id]" ).length, 0,
+ assert.equal( $( ".ui-helper-hidden-accessible [id]" ).length, 0,
"no id attributes within live region" );
}
} )
diff --git a/tests/unit/tooltip/deprecated.js b/tests/unit/tooltip/deprecated.js
index 7fc7d91a483..bce1a6c6ab5 100644
--- a/tests/unit/tooltip/deprecated.js
+++ b/tests/unit/tooltip/deprecated.js
@@ -1,12 +1,13 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/tooltip"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "tooltip: (deprecated) options" );
+QUnit.module( "tooltip: (deprecated) options" );
-test( "tooltipClass", function( assert ) {
- expect( 1 );
+QUnit.test( "tooltipClass", function( assert ) {
+ assert.expect( 1 );
var element = $( "#tooltipped1" ).tooltip( {
tooltipClass: "custom"
} ).tooltip( "open" );
diff --git a/tests/unit/tooltip/events.js b/tests/unit/tooltip/events.js
index 3cf65fc4ed1..3fbb683a588 100644
--- a/tests/unit/tooltip/events.js
+++ b/tests/unit/tooltip/events.js
@@ -1,57 +1,58 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/tooltip"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "tooltip: events" );
+QUnit.module( "tooltip: events" );
-test( "programmatic triggers", function() {
- expect( 4 );
+QUnit.test( "programmatic triggers", function( assert ) {
+ assert.expect( 4 );
var tooltip,
element = $( "#tooltipped1" ).tooltip();
element.one( "tooltipopen", function( event, ui ) {
tooltip = ui.tooltip;
- ok( !( "originalEvent" in event ), "open" );
- strictEqual( ui.tooltip[ 0 ],
+ assert.ok( !( "originalEvent" in event ), "open" );
+ assert.strictEqual( ui.tooltip[ 0 ],
$( "#" + element.data( "ui-tooltip-id" ) )[ 0 ], "ui.tooltip" );
} );
element.tooltip( "open" );
element.one( "tooltipclose", function( event, ui ) {
- ok( !( "originalEvent" in event ), "close" );
- strictEqual( ui.tooltip[ 0 ], tooltip[ 0 ], "ui.tooltip" );
+ assert.ok( !( "originalEvent" in event ), "close" );
+ assert.strictEqual( ui.tooltip[ 0 ], tooltip[ 0 ], "ui.tooltip" );
} );
element.tooltip( "close" );
} );
-test( "mouse events", function() {
- expect( 2 );
+QUnit.test( "mouse events", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tooltipped1" ).tooltip();
element.on( "tooltipopen", function( event ) {
- deepEqual( event.originalEvent.type, "mouseover" );
+ assert.deepEqual( event.originalEvent.type, "mouseover" );
} );
element.trigger( "mouseover" );
element.on( "tooltipclose", function( event ) {
- deepEqual( event.originalEvent.type, "mouseleave" );
+ assert.deepEqual( event.originalEvent.type, "mouseleave" );
} );
element.trigger( "focusout" );
element.trigger( "mouseleave" );
} );
-test( "focus events", function() {
- expect( 2 );
+QUnit.test( "focus events", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tooltipped1" ).tooltip();
element.on( "tooltipopen", function( event ) {
- deepEqual( event.originalEvent.type, "focusin" );
+ assert.deepEqual( event.originalEvent.type, "focusin" );
} );
element.trigger( "focusin" );
element.on( "tooltipclose", function( event ) {
- deepEqual( event.originalEvent.type, "focusout" );
+ assert.deepEqual( event.originalEvent.type, "focusout" );
} );
element.trigger( "mouseleave" );
element.trigger( "focusout" );
diff --git a/tests/unit/tooltip/methods.js b/tests/unit/tooltip/methods.js
index 31fe86532d0..e98d1b9edc0 100644
--- a/tests/unit/tooltip/methods.js
+++ b/tests/unit/tooltip/methods.js
@@ -1,12 +1,13 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/tooltip"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "tooltip: methods" );
+QUnit.module( "tooltip: methods" );
-test( "destroy", function( assert ) {
- expect( 3 );
+QUnit.test( "destroy", function( assert ) {
+ assert.expect( 3 );
var element = $( "#tooltipped1" );
assert.domEqual( "#tooltipped1", function() {
@@ -20,89 +21,89 @@ test( "destroy", function( assert ) {
.tooltip( "open", $.Event( "mouseover", { target: element[ 0 ] } ) )
.tooltip( "destroy" );
} );
- equal( $( ".ui-tooltip" ).length, 0 );
+ assert.equal( $( ".ui-tooltip" ).length, 0 );
} );
-test( "open/close", function() {
- expect( 3 );
+QUnit.test( "open/close", function( assert ) {
+ assert.expect( 3 );
$.fx.off = true;
var tooltip,
element = $( "#tooltipped1" ).tooltip();
- equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
element.tooltip( "open" );
tooltip = $( "#" + element.data( "ui-tooltip-id" ) );
- ok( tooltip.is( ":visible" ) );
+ assert.ok( tooltip.is( ":visible" ) );
element.tooltip( "close" );
- ok( tooltip.is( ":hidden" ) );
+ assert.ok( tooltip.is( ":hidden" ) );
$.fx.off = false;
} );
// #8626 - Calling open() without an event
-test( "open/close with tracking", function() {
- expect( 3 );
+QUnit.test( "open/close with tracking", function( assert ) {
+ assert.expect( 3 );
$.fx.off = true;
var tooltip,
element = $( "#tooltipped1" ).tooltip( { track: true } );
- equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
element.tooltip( "open" );
tooltip = $( "#" + element.data( "ui-tooltip-id" ) );
- ok( tooltip.is( ":visible" ) );
+ assert.ok( tooltip.is( ":visible" ) );
element.tooltip( "close" );
- ok( tooltip.is( ":hidden" ) );
+ assert.ok( tooltip.is( ":hidden" ) );
$.fx.off = false;
} );
-test( "enable/disable", function( assert ) {
- expect( 11 );
+QUnit.test( "enable/disable", function( assert ) {
+ assert.expect( 11 );
$.fx.off = true;
var tooltip,
element = $( "#tooltipped1" ).tooltip();
- equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "no tooltip on init" );
element.tooltip( "open" );
tooltip = $( "#" + element.data( "ui-tooltip-id" ) );
- ok( tooltip.is( ":visible" ) );
+ assert.ok( tooltip.is( ":visible" ) );
element.tooltip( "disable" );
- equal( $( ".ui-tooltip" ).length, 0, "no tooltip when disabled" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "no tooltip when disabled" );
assert.lacksClasses( element.tooltip( "widget" ), "ui-state-disabled" );
- ok( !element.tooltip( "widget" ).attr( "aria-disabled" ), "element doesn't get aria-disabled" );
+ assert.ok( !element.tooltip( "widget" ).attr( "aria-disabled" ), "element doesn't get aria-disabled" );
assert.lacksClasses( element.tooltip( "widget" ), "ui-tooltip-disabled" );
- equal( tooltip.attr( "title" ), null, "title removed on disable" );
+ assert.equal( tooltip.attr( "title" ), null, "title removed on disable" );
element.tooltip( "open" );
- equal( $( ".ui-tooltip" ).length, 0, "open does nothing when disabled" );
+ assert.equal( $( ".ui-tooltip" ).length, 0, "open does nothing when disabled" );
element.tooltip( "enable" );
- equal( element.attr( "title" ), "anchortitle", "title restored on enable" );
+ assert.equal( element.attr( "title" ), "anchortitle", "title restored on enable" );
// #9719 - Title should be preserved after disabling twice
element.tooltip( "disable" );
element.tooltip( "disable" );
element.tooltip( "enable" );
- equal( element.attr( "title" ), "anchortitle", "title restored on enable after being disabled twice" );
+ assert.equal( element.attr( "title" ), "anchortitle", "title restored on enable after being disabled twice" );
element.tooltip( "open" );
tooltip = $( "#" + element.data( "ui-tooltip-id" ) );
- ok( tooltip.is( ":visible" ) );
+ assert.ok( tooltip.is( ":visible" ) );
$.fx.off = false;
} );
-test( "widget", function() {
- expect( 2 );
+QUnit.test( "widget", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tooltipped1" ).tooltip(),
widgetElement = element.tooltip( "widget" );
- equal( widgetElement.length, 1, "one element" );
- strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" );
+ assert.equal( widgetElement.length, 1, "one element" );
+ assert.strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" );
} );
-test( "preserve changes to title attributes on close and destroy", function() {
- expect( 6 );
+QUnit.test( "preserve changes to title attributes on close and destroy", function( assert ) {
+ assert.expect( 6 );
var element = $( "#tooltipped1" ),
changed = "changed title text",
original = "original title text",
@@ -136,7 +137,7 @@ test( "preserve changes to title attributes on close and destroy", function() {
element.removeAttr( "title" );
}
element.tooltip( test.method );
- equal( $( "#tooltipped1" ).attr( "title" ), test.expected );
+ assert.equal( $( "#tooltipped1" ).attr( "title" ), test.expected );
} );
} );
diff --git a/tests/unit/tooltip/options.js b/tests/unit/tooltip/options.js
index a35d140fbd9..6dec36a6cbe 100644
--- a/tests/unit/tooltip/options.js
+++ b/tests/unit/tooltip/options.js
@@ -1,26 +1,27 @@
define( [
+ "qunit",
"jquery",
"ui/widgets/tooltip"
-], function( $ ) {
+], function( QUnit, $ ) {
-module( "tooltip: options" );
+QUnit.module( "tooltip: options" );
-test( "disabled: true", function() {
- expect( 1 );
+QUnit.test( "disabled: true", function( assert ) {
+ assert.expect( 1 );
$( "#tooltipped1" ).tooltip( {
disabled: true
} ).tooltip( "open" );
- equal( $( ".ui-tooltip" ).length, 0 );
+ assert.equal( $( ".ui-tooltip" ).length, 0 );
} );
-test( "content: default", function() {
- expect( 1 );
+QUnit.test( "content: default", function( assert ) {
+ assert.expect( 1 );
var element = $( "#tooltipped1" ).tooltip().tooltip( "open" );
- deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "anchortitle" );
+ assert.deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "anchortitle" );
} );
-test( "content: default; HTML escaping", function() {
- expect( 2 );
+QUnit.test( "content: default; HTML escaping", function( assert ) {
+ assert.expect( 2 );
var scriptText = "",
element = $( "#tooltipped1" );
@@ -28,45 +29,46 @@ test( "content: default; HTML escaping", function() {
element.attr( "title", scriptText )
.tooltip()
.tooltip( "open" );
- equal( $.ui.tooltip.hacked, false, "script did not execute" );
- deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), scriptText,
+ assert.equal( $.ui.tooltip.hacked, false, "script did not execute" );
+ assert.deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), scriptText,
"correct tooltip text" );
} );
-test( "content: return string", function() {
- expect( 1 );
+QUnit.test( "content: return string", function( assert ) {
+ assert.expect( 1 );
var element = $( "#tooltipped1" ).tooltip( {
content: function() {
return "customstring";
}
} ).tooltip( "open" );
- deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "customstring" );
+ assert.deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "customstring" );
} );
-test( "content: return jQuery", function() {
- expect( 2 );
+QUnit.test( "content: return jQuery", function( assert ) {
+ assert.expect( 2 );
var element = $( "#tooltipped1" ).tooltip( {
content: function() {
return $( "
" ).html( "cu
stomstring" );
}
} ).tooltip( "open" ),
liveRegion = element.tooltip( "instance" ).liveRegion;
- deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "customstring" );
- equal( liveRegion.children().last().html().toLowerCase(), "
customstring
",
+ assert.deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "customstring" );
+ assert.equal( liveRegion.children().last().html().toLowerCase(), "
customstring
",
"The accessibility live region will strip the ids but keep the structure" );
} );
-asyncTest( "content: sync + async callback", function() {
- expect( 2 );
+QUnit.test( "content: sync + async callback", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 2 );
var element = $( "#tooltipped1" ).tooltip( {
content: function( response ) {
setTimeout( function() {
- deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "loading..." );
+ assert.deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "loading..." );
response( "customstring2" );
setTimeout( function() {
- deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "customstring2" );
- start();
+ assert.deepEqual( $( "#" + element.data( "ui-tooltip-id" ) ).text(), "customstring2" );
+ ready();
}, 13 );
}, 13 );
return "loading...";
@@ -75,8 +77,9 @@ asyncTest( "content: sync + async callback", function() {
} );
// http://bugs.jqueryui.com/ticket/8740
-asyncTest( "content: async callback loses focus before load", function() {
- expect( 1 );
+QUnit.test( "content: async callback loses focus before load", function( assert ) {
+ var ready = assert.async();
+ assert.expect( 1 );
var element = $( "#tooltipped1" ).tooltip( {
content: function( response ) {
@@ -85,9 +88,9 @@ asyncTest( "content: async callback loses focus before load", function() {
setTimeout( function() {
response( "sometext" );
setTimeout( function() {
- ok( !$( "#" + element.data( "ui-tooltip-id" ) ).is( ":visible" ),
+ assert.ok( !$( "#" + element.data( "ui-tooltip-id" ) ).is( ":visible" ),
"Tooltip should not display" );
- start();
+ ready();
} );
} );
} );
@@ -96,8 +99,8 @@ asyncTest( "content: async callback loses focus before load", function() {
element.trigger( "mouseover" );
} );
-test( "content: change while open", function() {
- expect( 2 ) ;
+QUnit.test( "content: change while open", function( assert ) {
+ assert.expect( 2 ) ;
var element = $( "#tooltipped1" ).tooltip( {
content: function() {
return "old";
@@ -105,52 +108,52 @@ test( "content: change while open", function() {
} );
element.one( "tooltipopen", function( event, ui ) {
- equal( ui.tooltip.text(), "old", "original content" );
+ assert.equal( ui.tooltip.text(), "old", "original content" );
element.tooltip( "option", "content", function() {
return "new";
} );
- equal( ui.tooltip.text(), "new", "updated content" );
+ assert.equal( ui.tooltip.text(), "new", "updated content" );
} );
element.tooltip( "open" );
} );
-test( "content: string", function() {
- expect( 1 );
+QUnit.test( "content: string", function( assert ) {
+ assert.expect( 1 );
$( "#tooltipped1" ).tooltip( {
content: "just a string",
open: function( event, ui ) {
- equal( ui.tooltip.text(), "just a string" );
+ assert.equal( ui.tooltip.text(), "just a string" );
}
} ).tooltip( "open" );
} );
-test( "content: element", function() {
- expect( 1 );
+QUnit.test( "content: element", function( assert ) {
+ assert.expect( 1 );
var content = "
this is a test of the emergency broadcast system.
",
element = $( content )[ 0 ];
$( "#tooltipped1" ).tooltip( {
content: element,
open: function( event, ui ) {
- equal( ui.tooltip.children().html().toLowerCase(), content );
+ assert.equal( ui.tooltip.children().html().toLowerCase(), content );
}
} ).tooltip( "open" );
} );
-test( "content: jQuery", function() {
- expect( 1 );
+QUnit.test( "content: jQuery", function( assert ) {
+ assert.expect( 1 );
var content = "
this is a test of the emergency broadcast system.
",
element = $( content );
$( "#tooltipped1" ).tooltip( {
content: element,
open: function( event, ui ) {
- equal( ui.tooltip.children().html().toLowerCase(), content );
+ assert.equal( ui.tooltip.children().html().toLowerCase(), content );
}
} ).tooltip( "open" );
} );
-test( "items", function() {
- expect( 2 );
+QUnit.test( "items", function( assert ) {
+ assert.expect( 2 );
var event,
element = $( "#qunit-fixture" ).tooltip( {
items: "#fixture-span"
@@ -159,18 +162,18 @@ test( "items", function() {
event = $.Event( "mouseenter" );
event.target = $( "#fixture-span" )[ 0 ];
element.tooltip( "open", event );
- deepEqual( $( "#" + $( "#fixture-span" ).data( "ui-tooltip-id" ) ).text(), "title-text" );
+ assert.deepEqual( $( "#" + $( "#fixture-span" ).data( "ui-tooltip-id" ) ).text(), "title-text" );
// Make sure default [title] doesn't get used
event.target = $( "#tooltipped1" )[ 0 ];
element.tooltip( "open", event );
- deepEqual( $( "#tooltipped1" ).data( "ui-tooltip-id" ), undefined );
+ assert.deepEqual( $( "#tooltipped1" ).data( "ui-tooltip-id" ), undefined );
element.tooltip( "destroy" );
} );
-test( "track + show delay", function() {
- expect( 2 );
+QUnit.test( "track + show delay", function( assert ) {
+ assert.expect( 2 );
var event,
leftVal = 314,
topVal = 159,
@@ -200,16 +203,16 @@ test( "track + show delay", function() {
event.pageY = topVal;
element.trigger( event );
- equal( $( ".ui-tooltip" ).css( "left" ), leftVal + offsetVal + "px" );
- equal( $( ".ui-tooltip" ).css( "top" ), topVal + offsetVal + "px" );
+ assert.equal( $( ".ui-tooltip" ).css( "left" ), leftVal + offsetVal + "px" );
+ assert.equal( $( ".ui-tooltip" ).css( "top" ), topVal + offsetVal + "px" );
} );
-test( "track and programmatic focus", function() {
- expect( 1 );
+QUnit.test( "track and programmatic focus", function( assert ) {
+ assert.expect( 1 );
$( "#qunit-fixture div input" ).tooltip( {
track: true
} ).trigger( "focus" );
- equal( "inputtitle", $( ".ui-tooltip" ).text() );
+ assert.equal( "inputtitle", $( ".ui-tooltip" ).text() );
} );
} );
From 10741ef7f80b7edafe81d5d4a1716ad22d4a8ee4 Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Wed, 6 Apr 2016 19:36:47 +0530
Subject: [PATCH 24/26] Widget: Shift to use no globals
---
tests/unit/widget/animation.js | 114 +++---
tests/unit/widget/classes.js | 21 +-
tests/unit/widget/core.js | 706 +++++++++++++++++----------------
tests/unit/widget/extend.js | 61 +--
4 files changed, 457 insertions(+), 445 deletions(-)
diff --git a/tests/unit/widget/animation.js b/tests/unit/widget/animation.js
index 9f9f9271074..bbd3ca854a1 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 b837aac34fb..d355c3a3632 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 93bfe875af6..00dcb16110f 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 = "";
$.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 = $( "" );
$.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 = $( "" );
$.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 = $( "
" )
.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 = $( "
" ).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 = $( "
" )
.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" );
};
$( "
" ).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" );
};
$( "
" ).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" );
};
$( "
" ).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() {
$( "
" ).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() {
} );
$( "
" ).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 = $( "
" ),
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 = $( "
" ).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 = $( "
" ).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" );
}
} );
$( "
" ).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" );
}
} );
$( "
" ).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" );
};
$( "
" ).testWidget();
method = function( value ) {
- strictEqual( value, true, "._setOptionDisabled called on init when disabled" );
+ assert.strictEqual( value, true, "._setOptionDisabled called on init when disabled" );
};
widget = $( "
" ).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 = $( "
" ).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 = $( "
" );
$.widget( "ui.testWidget", {
_create: function() {},
@@ -781,11 +782,11 @@ test( ".widget() - overriden", function() {
return wrapper;
}
} );
- deepEqual( wrapper[ 0 ], $( "
" ).testWidget().testWidget( "widget" )[ 0 ] );
+ assert.deepEqual( wrapper[ 0 ], $( "
" ).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 = $( "
" );
- 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 = $( "
" )
@@ -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 = $( "
" )
@@ -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 = $( "
" )
.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 = $( "
hello world
" );
@@ -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() {
$( "
child
" ).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( $( "
" ).testWidget1().testWidget1( "method" ),
+ assert.equal( $( "
" ).testWidget1().testWidget1( "method" ),
"mixed testWidget1", "testWidget1 mixin successful" );
- equal( $( "
" ).testWidget2().testWidget2( "method" ),
+ assert.equal( $( "
" ).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 = $( "
" );
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 = $( "
" );
@@ -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 93afd731ae1..36575200b61 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" );
} );
} );
From e568225a30ffae4376189a5998142692e704c3be Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Wed, 6 Apr 2016 21:29:16 +0530
Subject: [PATCH 25/26] Tests: Update common lib to use no globals
---
tests/lib/common.js | 56 +++++++++++++++++++++++----------------------
1 file changed, 29 insertions(+), 27 deletions(-)
diff --git a/tests/lib/common.js b/tests/lib/common.js
index d0d72ab8a10..57b7768cf93 100644
--- a/tests/lib/common.js
+++ b/tests/lib/common.js
@@ -1,6 +1,7 @@
define( [
- "jquery"
-], function( $ ) {
+ "qunit",
+ "jquery" ],
+function( QUnit, $ ) {
var exports = {};
@@ -8,39 +9,39 @@ function testWidgetDefaults( widget, defaults ) {
var pluginDefaults = $.ui[ widget ].prototype.options;
// Ensure that all defaults have the correct value
- test( "defined defaults", function() {
+ QUnit.test( "defined defaults", function( assert ) {
var count = 0;
$.each( defaults, function( key, val ) {
- expect( ++count );
+ assert.expect( ++count );
if ( $.isFunction( val ) ) {
- ok( $.isFunction( pluginDefaults[ key ] ), key );
+ assert.ok( $.isFunction( pluginDefaults[ key ] ), key );
return;
}
- deepEqual( pluginDefaults[ key ], val, key );
+ assert.deepEqual( pluginDefaults[ key ], val, key );
} );
} );
// Ensure that all defaults were tested
- test( "tested defaults", function() {
+ QUnit.test( "tested defaults", function( assert ) {
var count = 0;
$.each( pluginDefaults, function( key ) {
- expect( ++count );
- ok( key in defaults, key );
+ assert.expect( ++count );
+ assert.ok( key in defaults, key );
} );
} );
}
function testWidgetOverrides( widget ) {
if ( $.uiBackCompat === false ) {
- test( "$.widget overrides", function() {
- expect( 4 );
+ QUnit.test( "$.widget overrides", function( assert ) {
+ assert.expect( 4 );
$.each( [
"_createWidget",
"destroy",
"option",
"_trigger"
], function( i, method ) {
- strictEqual( $.ui[ widget ].prototype[ method ],
+ assert.strictEqual( $.ui[ widget ].prototype[ method ],
$.Widget.prototype[ method ], "should not override " + method );
} );
} );
@@ -48,24 +49,24 @@ function testWidgetOverrides( widget ) {
}
function testBasicUsage( widget ) {
- test( "basic usage", function() {
- expect( 3 );
+ QUnit.test( "basic usage", function( assert ) {
+ assert.expect( 3 );
var defaultElement = $.ui[ widget ].prototype.defaultElement;
$( defaultElement ).appendTo( "body" )[ widget ]().remove();
- ok( true, "initialized on element" );
+ assert.ok( true, "initialized on element" );
$( defaultElement )[ widget ]().remove();
- ok( true, "initialized on disconnected DOMElement - never connected" );
+ assert.ok( true, "initialized on disconnected DOMElement - never connected" );
// Ensure manipulating removed elements works (#3664)
$( defaultElement ).appendTo( "body" ).remove()[ widget ]().remove();
- ok( true, "initialized on disconnected DOMElement - removed" );
+ assert.ok( true, "initialized on disconnected DOMElement - removed" );
} );
}
exports.testWidget = function( widget, settings ) {
- module( widget + ": common widget" );
+ QUnit.module( widget + ": common widget" );
exports.testJshint( "/widgets/" + widget );
testWidgetDefaults( widget, settings.defaults );
@@ -73,9 +74,9 @@ exports.testWidget = function( widget, settings ) {
if ( !settings.noDefaultElement ) {
testBasicUsage( widget );
}
- test( "version", function() {
- expect( 1 );
- ok( "version" in $.ui[ widget ].prototype, "version property exists" );
+ QUnit.test( "version", function( assert ) {
+ assert.expect( 1 );
+ assert.ok( "version" in $.ui[ widget ].prototype, "version property exists" );
} );
};
@@ -87,9 +88,10 @@ exports.testJshint = function( module ) {
return;
}
- asyncTest( "JSHint", function() {
+ QUnit.test( "JSHint", function( assert ) {
+ var ready = assert.async();
require( [ "jshint" ], function() {
- expect( 1 );
+ assert.expect( 1 );
$.when(
$.ajax( {
@@ -119,12 +121,12 @@ exports.testJshint = function( module ) {
return "[L" + error.line + ":C" + error.character + "] " +
error.reason + "\n" + error.evidence + "\n";
} ).join( "\n" );
- ok( passed, errors );
- start();
+ assert.ok( passed, errors );
+ ready();
} )
.fail( function( hintError, srcError ) {
- ok( false, "error loading source: " + ( hintError || srcError ).statusText );
- start();
+ assert.ok( false, "error loading source: " + ( hintError || srcError ).statusText );
+ ready();
} );
} );
} );
From 2e770153c5c1e7a4a755e2aa249f69a246fd17f7 Mon Sep 17 00:00:00 2001
From: Amanpreet Singh
Date: Thu, 14 Apr 2016 00:12:43 +0530
Subject: [PATCH 26/26] Tests: Remove all qunit global excludes from jshint
config
---
tests/.jshintrc | 15 +--------------
1 file changed, 1 insertion(+), 14 deletions(-)
diff --git a/tests/.jshintrc b/tests/.jshintrc
index 04d5371fc7e..6bdcee94db9 100644
--- a/tests/.jshintrc
+++ b/tests/.jshintrc
@@ -18,24 +18,11 @@
"jquery": true,
"globals": {
- "asyncTest": false,
- "deepEqual": false,
"define": false,
- "equal": false,
- "expect": false,
"Globalize": false,
- "module": false,
- "notEqual": false,
- "notDeepEqual": false,
- "notStrictEqual": false,
- "ok": false,
- "QUnit": true,
+ "QUnit": false,
"require": true,
"requirejs": true,
- "start": false,
- "strictEqual": false,
- "stop": false,
- "test": false,
"JSHINT": false
}
}