/inventoryBrowser/node_modules/jquery-ui/tests/unit/slider/core.js |
@@ -0,0 +1,322 @@ |
define( [ |
"qunit", |
"jquery", |
"ui/widgets/slider" |
], function( QUnit, $ ) { |
|
var element, options; |
|
function handle() { |
return element.find( ".ui-slider-handle" ); |
} |
|
// Slider Tests |
QUnit.module( "slider: core" ); |
|
QUnit.test( "markup structure", function( assert ) { |
assert.expect( 4 ); |
var element = $( "<div>" ).slider( { range: true } ), |
handle = element.find( "span" ), |
range = element.find( "div" ); |
|
assert.hasClasses( element, "ui-slider ui-slider-horizontal ui-widget ui-widget-content" ); |
assert.hasClasses( range, "ui-slider-range ui-widget-header" ); |
assert.hasClasses( handle[ 0 ], "ui-slider-handle" ); |
assert.hasClasses( handle[ 1 ], "ui-slider-handle" ); |
} ); |
|
QUnit.test( "custom handle", function( assert ) { |
assert.expect( 3 ); |
|
var element = $( "#slider-custom-handle" ).slider(); |
var customHandle = $( ".custom-handle" ); |
var sliderHandles = element.find( ".ui-slider-handle" ); |
|
assert.equal( sliderHandles.length, 1, "Only one handle" ); |
assert.strictEqual( sliderHandles[ 0 ], customHandle[ 0 ], "Correct handle" ); |
assert.equal( customHandle.attr( "tabIndex" ), 0, "tabIndex" ); |
} ); |
|
QUnit.test( "keydown HOME on handle sets value to min", function( assert ) { |
assert.expect( 2 ); |
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "horizontal", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", 0 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.HOME } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
element.slider( "destroy" ); |
|
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "vertical", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", 0 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.HOME } ); |
assert.equal( element.slider( "value" ), options.min ) ; |
|
element.slider( "destroy" ); |
} ); |
|
QUnit.test( "keydown END on handle sets value to max", function( assert ) { |
assert.expect( 2 ); |
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "horizontal", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", 0 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.END } ); |
assert.equal( element.slider( "value" ), options.max ) ; |
|
element.slider( "destroy" ); |
|
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "vertical", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", 0 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.END } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
element.slider( "destroy" ); |
} ); |
|
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 = $( "<div></div>" ); |
options = { |
max: 100, |
min: 0, |
orientation: orientation, |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", 70 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } ); |
assert.equal( element.slider( "value" ), 90 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } ); |
assert.equal( element.slider( "value" ), 100 ); |
|
element.slider( "destroy" ); |
} ); |
} ); |
|
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 = $( "<div></div>" ); |
options = { |
max: 100, |
min: 0, |
orientation: orientation, |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", 30 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } ); |
assert.equal( element.slider( "value" ), 10 ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } ); |
assert.equal( element.slider( "value" ), 0 ); |
|
element.slider( "destroy" ); |
} ); |
} ); |
|
QUnit.test( "keydown UP on handle increases value by step, not greater than max", function( assert ) { |
assert.expect( 4 ); |
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "horizontal", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.max - options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
element.slider( "destroy" ); |
|
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "vertical", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.max - options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
element.slider( "destroy" ); |
} ); |
|
QUnit.test( "keydown RIGHT on handle increases value by step, not greater than max", function( assert ) { |
assert.expect( 4 ); |
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "horizontal", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.max - options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
element.slider( "destroy" ); |
|
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "vertical", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.max - options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } ); |
assert.equal( element.slider( "value" ), options.max ); |
|
element.slider( "destroy" ); |
} ); |
|
QUnit.test( "keydown DOWN on handle decreases value by step, not less than min", function( assert ) { |
assert.expect( 4 ); |
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "horizontal", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.min + options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
element.slider( "destroy" ); |
|
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "vertical", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.min + options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
element.slider( "destroy" ); |
} ); |
|
QUnit.test( "keydown LEFT on handle decreases value by step, not less than min", function( assert ) { |
assert.expect( 4 ); |
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "horizontal", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.min + options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
element.slider( "destroy" ); |
|
element = $( "<div></div>" ); |
options = { |
max: 5, |
min: -5, |
orientation: "vertical", |
step: 1 |
}; |
element.slider( options ); |
|
element.slider( "value", options.min + options.step ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } ); |
assert.equal( element.slider( "value" ), options.min ); |
|
element.slider( "destroy" ); |
} ); |
|
} ); |
/inventoryBrowser/node_modules/jquery-ui/tests/unit/slider/events.js |
@@ -0,0 +1,233 @@ |
define( [ |
"qunit", |
"jquery", |
"ui/widgets/slider" |
], function( QUnit, $ ) { |
|
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" |
QUnit.test( "mouse based interaction", function( assert ) { |
assert.expect( 4 ); |
|
var element = $( "#slider1" ) |
.slider( { |
start: function( event ) { |
assert.equal( event.originalEvent.type, "mousedown", "start triggered by mousedown" ); |
}, |
slide: function( event ) { |
assert.equal( event.originalEvent.type, "mousemove", "slider triggered by mousemove" ); |
}, |
stop: function( event ) { |
assert.equal( event.originalEvent.type, "mouseup", "stop triggered by mouseup" ); |
}, |
change: function( event ) { |
assert.equal( event.originalEvent.type, "mouseup", "change triggered by mouseup" ); |
} |
} ); |
|
element.find( ".ui-slider-handle" ).eq( 0 ) |
.simulate( "drag", { dx: 10, dy: 10 } ); |
|
} ); |
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 ) { |
assert.equal( event.originalEvent.type, "keydown", "start triggered by keydown" ); |
}, |
slide: function() { |
assert.ok( false, "Slider never triggered by keys" ); |
}, |
stop: function( event ) { |
assert.equal( event.originalEvent.type, "keyup", "stop triggered by keyup" ); |
}, |
change: function( event ) { |
assert.equal( event.originalEvent.type, "keyup", "change triggered by keyup" ); |
} |
} ); |
|
element.find( ".ui-slider-handle" ).eq( 0 ) |
.simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } ) |
.simulate( "keypress", { keyCode: $.ui.keyCode.LEFT } ) |
.simulate( "keyup", { keyCode: $.ui.keyCode.LEFT } ); |
|
} ); |
QUnit.test( "programmatic event triggers", function( assert ) { |
assert.expect( 6 ); |
|
// Test value method |
var element = $( "<div></div>" ) |
.slider( { |
change: function() { |
assert.ok( true, "change triggered by value method" ); |
} |
} ) |
.slider( "value", 0 ); |
|
// Test values method |
element = $( "<div></div>" ) |
.slider( { |
values: [ 10, 20 ], |
change: function() { |
assert.ok( true, "change triggered by values method" ); |
} |
} ) |
.slider( "values", [ 80, 90 ] ); |
|
// Test value option |
element = $( "<div></div>" ) |
.slider( { |
change: function() { |
assert.ok( true, "change triggered by value option" ); |
} |
} ) |
.slider( "option", "value", 0 ); |
|
// Test values option |
element = $( "<div></div>" ) |
.slider( { |
values: [ 10, 20 ], |
change: function() { |
assert.ok( true, "change triggered by values option" ); |
} |
} ) |
.slider( "option", "values", [ 80, 90 ] ); |
|
} ); |
|
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 ) { |
assert.equal( handles.index( ui.handle ), 2, "rightmost handle activated when overlapping at minimum (#3736)" ); |
} |
} ), |
handles = element.find( ".ui-slider-handle" ); |
handles.eq( 0 ).simulate( "drag", { dx: 10 } ); |
element.slider( "destroy" ); |
|
element = $( "#slider1" ) |
.slider( { |
values: [ 10, 10, 10 ], |
max: 10, |
start: function( event, ui ) { |
assert.equal( handles.index( ui.handle ), 0, "leftmost handle activated when overlapping at maximum" ); |
} |
} ), |
handles = element.find( ".ui-slider-handle" ); |
handles.eq( 0 ).simulate( "drag", { dx: -10 } ); |
element.slider( "destroy" ); |
|
element = $( "#slider1" ) |
.slider( { |
values: [ 19, 20 ] |
} ), |
handles = element.find( ".ui-slider-handle" ); |
handles.eq( 0 ).simulate( "drag", { dx: 10 } ); |
element.one( "slidestart", function( event, ui ) { |
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" ); |
|
element = $( "#slider1" ) |
.slider( { |
values: [ 19, 20 ] |
} ), |
handles = element.find( ".ui-slider-handle" ); |
handles.eq( 1 ).simulate( "drag", { dx: -10 } ); |
element.one( "slidestart", function( event, ui ) { |
assert.equal( handles.index( ui.handle ), 1, "right handle activated if right was moved last (#3467)" ); |
} ); |
handles.eq( 0 ).simulate( "drag", { dx: 10 } ); |
|
element = $( "#slider1" ) |
.slider( { |
range: true, |
min: 0, |
max: 100, |
values: [ 0, 50 ] |
} ), |
handles = element.find( ".ui-slider-handle" ); |
|
element.slider( "option", { values: [ 100, 100 ] } ); |
handles.eq( 0 ).simulate( "drag", { dx: -10 } ); |
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 } ); |
assert.equal( element.slider( "values" )[ 1 ], 1, "setting both values of range slider to the minimum doesn't lock slider" ); |
} ); |
|
QUnit.test( "event data", function( assert ) { |
assert.expect( 6 ); |
|
var slideHandleIndex = 3, |
values = [ 8, 9, 7, 4 ], |
newValues = [ 8, 9, 7, 5 ], |
element = $( "#slider1" ) |
.slider( { |
values: values, |
start: function( event, ui ) { |
assert.deepEqual( ui, expectedUiHash, "passing ui to start event" ); |
}, |
slide: function( event, ui ) { |
assert.deepEqual( ui, expectedChangedUiHash, "passing ui to slide event" ); |
}, |
stop: function( event, ui ) { |
assert.deepEqual( ui, expectedChangedUiHash, "passing ui to stop event" ); |
}, |
change: function( event, ui ) { |
assert.deepEqual( ui, expectedChangedUiHash, "passing ui to change event" ); |
} |
} ), |
handles = element.find( ".ui-slider-handle" ), |
expectedUiHash = { |
handle: handles.eq( slideHandleIndex )[ 0 ], |
handleIndex: slideHandleIndex, |
values: values, |
value: values[ slideHandleIndex ] |
}, |
expectedChangedUiHash = $.extend( {}, expectedUiHash, { |
values: newValues, |
value: newValues[ slideHandleIndex ] |
} ); |
|
handles.eq( slideHandleIndex ).simulate( "drag", { dx: 10 } ); |
|
element.slider( "destroy" ); |
element = $( "#slider1" ).slider( { |
min: 0, |
max: 100, |
value: 1, |
slide: function( event, ui ) { |
assert.equal( ui.value, 0, "should pass 0 value if slider reaches it" ); |
} |
} ); |
handles = element.find( ".ui-slider-handle" ); |
handles.eq( 0 ).simulate( "drag", { dx: -10 } ); |
|
element.slider( "destroy" ); |
element = $( "#slider1" ).slider( { |
min: 0, |
max: 100, |
values: [ 1, 2 ], |
slide: function( event, ui ) { |
assert.equal( ui.value, 0, "should pass 0 value if one of handles reaches it" ); |
} |
} ); |
handles = element.find( ".ui-slider-handle" ); |
handles.eq( 0 ).simulate( "drag", { dx: -10 } ); |
} ); |
|
} ); |
/inventoryBrowser/node_modules/jquery-ui/tests/unit/slider/methods.js |
@@ -0,0 +1,165 @@ |
define( [ |
"qunit", |
"jquery", |
"ui/widgets/slider" |
], function( QUnit, $ ) { |
|
QUnit.module( "slider: methods" ); |
|
QUnit.test( "init", function( assert ) { |
assert.expect( 5 ); |
|
$( "<div></div>" ).appendTo( "body" ).slider().remove(); |
assert.ok( true, ".slider() called on element" ); |
|
$( [] ).slider().remove(); |
assert.ok( true, ".slider() called on empty collection" ); |
|
$( "<div></div>" ).slider().remove(); |
assert.ok( true, ".slider() called on disconnected DOMElement" ); |
|
var element = $( "<div></div>" ).slider(); |
element.slider( "option", "foo" ); |
element.remove(); |
assert.ok( true, "arbitrary option getter after init" ); |
|
$( "<div></div>" ).slider().slider( "option", "foo", "bar" ).remove(); |
assert.ok( true, "arbitrary option setter after init" ); |
} ); |
|
QUnit.test( "destroy", function( assert ) { |
assert.expect( 1 ); |
assert.domEqual( "#slider1", function() { |
$( "#slider1" ).slider().slider( "destroy" ); |
} ); |
} ); |
|
QUnit.test( "enable", function( assert ) { |
assert.expect( 3 ); |
var element, |
expected = $( "<div></div>" ).slider(), |
actual = expected.slider( "enable" ); |
assert.equal( actual, expected, "enable is chainable" ); |
|
element = $( "<div></div>" ).slider( { disabled: true } ); |
assert.hasClasses( element, "ui-state-disabled ui-slider-disabled" ); |
element.slider( "enable" ); |
assert.lacksClasses( element, "ui-state-disabled ui-slider-disabled" ); |
} ); |
|
QUnit.test( "disable", function( assert ) { |
assert.expect( 4 ); |
var element, |
expected = $( "<div></div>" ).slider(), |
actual = expected.slider( "disable" ); |
assert.equal( actual, expected, "disable is chainable" ); |
|
element = $( "<div></div>" ).slider( { disabled: false } ); |
assert.lacksClasses( element, "ui-state-disabled ui-slider-disabled" ); |
element.slider( "disable" ); |
assert.hasClasses( element, "ui-state-disabled ui-slider-disabled" ); |
assert.ok( !element.attr( "aria-disabled" ), "slider does not have aria-disabled attr after disable method call" ); |
} ); |
|
QUnit.test( "value", function( assert ) { |
assert.expect( 19 ); |
$( [ false, "min", "max" ] ).each( function() { |
var element = $( "<div></div>" ).slider( { |
range: this, |
value: 5 |
} ); |
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 = $( "<div></div>" ).slider( { |
min: -1, value: 0, max: 1 |
} ); |
|
// Min with value option vs value method |
element.slider( "option", "value", -2 ); |
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 |
element.slider( "option", "value", 2 ); |
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", { |
min: 2, |
value: 2, |
max: 2.4, |
step: 0.01 |
} ); |
element.slider( "option", "value", 2.4 ); |
assert.equal( element.slider( "value" ), 2.4, "value is set to max with 0.01 step" ); |
|
element = $( "<div></div>" ).slider( { |
value: 100, |
min: 10, |
max: 500, |
step: 50 |
} ); |
|
element.slider( "option", "value", 510 ); |
assert.equal( element.slider( "value" ), 460, "value is restricted to maximum valid step" ); |
} ); |
|
QUnit.test( "values, single step", function( assert ) { |
assert.expect( 8 ); |
|
var element = $( "<div></div>" ).slider( { |
range: false, |
min: 10, |
max: 100, |
step: 1, |
values: [ 20 ] |
} ); |
|
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 ); |
assert.equal( element.slider( "values", 0 ), 10, "values (index) - restrict against min" ); |
|
element.slider( "values", 0, 110 ); |
assert.equal( element.slider( "values", 0 ), 100, "values (index) - restrict against max" ); |
|
element.slider( "option", "range", true ); |
element.slider( "values", [ 20, 90 ] ); |
|
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 ] ); |
assert.deepEqual( element.slider( "values" ), [ 10, 100 ], "values - restricted against min and max" ); |
element.slider( "destroy" ); |
} ); |
|
QUnit.test( "values, multi step", function( assert ) { |
assert.expect( 2 ); |
|
var element = $( "<div></div>" ).slider( { |
range: false, |
min: 9, |
max: 20, |
step: 3, |
values: [ 9, 12 ] |
} ); |
assert.deepEqual( element.slider( "values" ), [ 9, 12 ], "values - evenly divisible by step" ); |
|
element.slider( "values", [ 10, 20 ] ); |
assert.deepEqual( element.slider( "values" ), [ 9, 18 ], "values - not evenly divisible by step" ); |
|
element.slider( "destroy" ); |
} ); |
|
} ); |
/inventoryBrowser/node_modules/jquery-ui/tests/unit/slider/options.js |
@@ -0,0 +1,404 @@ |
define( [ |
"qunit", |
"jquery", |
"ui/widgets/slider" |
], function( QUnit, $ ) { |
|
var element, options; |
|
function handle() { |
return element.find( ".ui-slider-handle" ); |
} |
|
QUnit.module( "slider: options" ); |
|
QUnit.test( "disabled", function( assert ) { |
assert.expect( 8 ); |
var count = 0; |
|
element = $( "#slider1" ).slider(); |
element.on( "slidestart", function() { |
count++; |
} ); |
|
// Enabled |
assert.lacksClasses( element, "ui-slider-disabled" ); |
assert.equal( element.slider( "option", "disabled" ), false, "is not disabled" ); |
|
handle().simulate( "drag", { dx: 10 } ); |
assert.equal( count, 1, "slider moved" ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } ); |
assert.equal( count, 2, "slider moved" ); |
|
// Disabled |
element.slider( "option", "disabled", true ); |
assert.hasClasses( element, "ui-slider-disabled" ); |
assert.equal( element.slider( "option", "disabled" ), true, "is disabled" ); |
|
handle().simulate( "drag", { dx: 10 } ); |
assert.equal( count, 2, "slider did not move" ); |
|
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } ); |
assert.equal( count, 2, "slider did not move" ); |
} ); |
|
QUnit.test( "max", function( assert ) { |
assert.expect( 7 ); |
element = $( "<div></div>" ); |
|
options = { |
max: 37, |
min: 6, |
orientation: "horizontal", |
step: 1, |
value: 50 |
}; |
|
element.slider( options ); |
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, |
min: 1, |
orientation: "horizontal", |
step: 3, |
value: 8.75 |
}; |
|
element.slider( options ); |
assert.ok( element.slider( "value" ) === 7, "value method is within max, edge Case" ); |
|
options.step = 2; |
|
element.slider( options ); |
assert.ok( element.slider( "value" ) === options.max, "value method will max, step is changed" ); |
element.slider( "destroy" ); |
|
options = { |
max: 60, |
min: 50, |
orientation: "horizontal", |
step: 0.1, |
value: 60 |
}; |
|
element.slider( options ); |
assert.ok( element.slider( "value" ) === options.max, "value method will max, step is changed and step is float" ); |
element.slider( "destroy" ); |
|
options = { |
max: 10.75, |
min: 1.22, |
orientation: "horizontal", |
step: 0.01, |
value: 10.75 |
}; |
|
element.slider( options ); |
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 ); |
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" ); |
} ); |
|
QUnit.test( "min", function( assert ) { |
assert.expect( 2 ); |
element = $( "<div></div>" ); |
|
options = { |
max: 37, |
min: 6, |
orientation: "vertical", |
step: 1, |
value: 2 |
}; |
|
element.slider( options ); |
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" ); |
|
} ); |
|
QUnit.test( "orientation", function( assert ) { |
assert.expect( 14 ); |
element = $( "#slider1" ); |
|
options = { |
max: 2, |
min: -2, |
orientation: "vertical", |
value: 1 |
}; |
|
var newValue, rangeSize, |
percentVal = ( options.value - options.min ) / ( options.max - options.min ) * 100; |
|
element.slider( options ).slider( "option", "orientation", "horizontal" ); |
assert.hasClasses( element, "ui-slider-horizontal" ); |
assert.lacksClasses( element, "ui-slider-vertical" ); |
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" ) ; |
|
options = { |
max: 2, |
min: -2, |
orientation: "horizontal", |
value: -1 |
}; |
|
percentVal = ( options.value - options.min ) / ( options.max - options.min ) * 100; |
|
element.slider( options ).slider( "option", "orientation", "vertical" ); |
assert.hasClasses( element, "ui-slider-vertical" ); |
assert.lacksClasses( element, "ui-slider-horizontal" ); |
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" ); |
|
newValue = 7; |
rangeSize = 500 - ( 500 * newValue / 10 ); |
element = $( "#slider2" ).slider( { |
range: "max", |
min: 0, |
max: 10 |
} ); |
|
element.slider( "option", "value", newValue ); |
element.slider( "option", "orientation", "vertical" ); |
assert.equal( element.find( ".ui-slider-range" ).width(), 12, |
"range should occupy all horizontal space after changing orientation to vertical" ); |
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" ); |
assert.equal( element.find( ".ui-slider-range " ).height(), 12, |
"range should occupy all vertical space after changing orientation to horizontal" ); |
assert.equal( element.find( ".ui-slider-range" ).width(), rangeSize, |
"range width of horizontal slider should be proportional to the value" ); |
|
element.slider( "destroy" ); |
|
element = $( "#slider2" ).slider( { |
range: true, |
min: 0, |
max: 100 |
} ); |
element.slider( "option", { values: [ 60, 70 ] } ); |
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" ); |
assert.equal( element.find( ".ui-slider-range " ).position().left, 0, |
"range should pull over to the track's border" ); |
|
element.slider( "destroy" ); |
} ); |
|
//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) |
QUnit.test( "step", function( assert ) { |
assert.expect( 9 ); |
element = $( "<div></div>" ).slider( { |
min: 0, |
value: 0, |
step: 10, |
max: 100 |
} ); |
assert.equal( element.slider( "value" ), 0 ); |
|
element.slider( "value", 1 ); |
assert.equal( element.slider( "value" ), 0 ); |
|
element.slider( "value", 9 ); |
assert.equal( element.slider( "value" ), 10 ); |
|
element.slider( "value", 11 ); |
assert.equal( element.slider( "value" ), 10 ); |
|
element.slider( "value", 19 ); |
assert.equal( element.slider( "value" ), 20 ); |
|
element = $( "<div></div>" ).slider( { |
min: 0, |
value: 0, |
step: 20, |
max: 100 |
} ); |
element.slider( "value", 0 ); |
|
element.slider( "option", "value", 1 ); |
assert.equal( element.slider( "value" ), 0 ); |
|
element.slider( "option", "value", 9 ); |
assert.equal( element.slider( "value" ), 0 ); |
|
element.slider( "option", "value", 11 ); |
assert.equal( element.slider( "value" ), 20 ); |
|
element.slider( "option", "value", 19 ); |
assert.equal( element.slider( "value" ), 20 ); |
|
element.slider( "destroy" ); |
} ); |
|
//Test( "value", function() { |
// ok(false, "missing test - untested code is broken code." ); |
//}); |
|
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 |
// of 1 slider updates options.values of all the others |
var ranges = $( [ |
document.createElement( "div" ), |
document.createElement( "div" ) |
] ).slider( { |
range: true, |
values: [ 25, 75 ] |
} ); |
|
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" |
); |
|
ranges.eq( 0 ).slider( "values", 0, 10 ); |
|
assert.notEqual( |
ranges.eq( 0 ).slider( "values", 0 ), |
ranges.eq( 1 ).slider( "values", 0 ), |
"the values for multiple sliders should be different" |
); |
} ); |
|
QUnit.test( "range", function( assert ) { |
assert.expect( 32 ); |
var range; |
|
// Min |
element = $( "<div></div>" ).slider( { |
range: "min", |
min: 1, |
max: 10, |
step: 1 |
} ); |
|
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 |
element = $( "<div></div>" ).slider( { |
range: "max", |
min: 1, |
max: 10, |
step: 1 |
} ); |
|
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 |
element = $( "<div></div>" ).slider( { |
range: true, |
min: 1, |
max: 10, |
step: 1 |
} ); |
|
range = element.find( ".ui-slider-range" ); |
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" ); |
|
// Change range from min to max |
element = $( "<div></div>" ).slider( { |
range: "min", |
min: 1, |
max: 10, |
step: 1 |
} ).slider( "option", "range", "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 |
element = $( "<div></div>" ).slider( { |
range: "max", |
min: 1, |
max: 10, |
step: 1 |
} ).slider( "option", "range", "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 |
element = $( "<div></div>" ).slider( { |
range: "max", |
min: 1, |
max: 10, |
step: 1 |
} ).slider( "option", "range", true ); |
|
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 |
element = $( "<div></div>" ).slider( { |
range: true, |
min: 1, |
max: 10, |
step: 1 |
} ).slider( "option", "range", "min" ); |
|
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 |
element = $( "<div></div>" ).slider( { |
range: true, |
min: 1, |
max: 10, |
step: 1 |
} ).slider( "option", "range", false ); |
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" ); |
} ); |
|
} ); |