jostreff/nsedit
1
0
Fork 0
mirror of https://github.com/tuxis-ie/nsedit.git synced 2025-05-24 00:24:07 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge commit 'd21ea7816e' as 'jquery-ui'

Browse source
This commit is contained in:
Mark Schouten 2016-08-05 13:20:20 +02:00
commit e904a80717
629 changed files with 341074 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

26
jquery-ui/tests/unit/slider/all.html Normal file
View file

@ -0,0 +1,26 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>jQuery UI Slider Test Suite</title>
<script src="../../../external/jquery/jquery.js"></script>
<link rel="stylesheet" href="../../../external/qunit/qunit.css">
<link rel="stylesheet" href="../qunit-composite.css">
<script src="../../../external/qunit/qunit.js"></script>
<script src="../qunit-composite.js"></script>
<script src="../subsuite.js"></script>
<script>
testAllVersions( "slider" );
</script>
</head>
<body>
<div id="qunit"></div>
<div id="qunit-fixture">
</div>
</body>
</html>

44
jquery-ui/tests/unit/slider/slider.html Normal file
View file

@ -0,0 +1,44 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>jQuery UI Slider Test Suite</title>
<script src="../../jquery.js"></script>
<link rel="stylesheet" href="../../../external/qunit/qunit.css">
<script src="../../../external/qunit/qunit.js"></script>
<script src="../../../external/jquery-simulate/jquery.simulate.js"></script>
<script src="../testsuite.js"></script>
<script>
TestHelpers.loadResources({
css: [ "core", "slider" ],
js: [
"ui/core.js",
"ui/widget.js",
"ui/mouse.js",
"ui/slider.js"
]
});
</script>
<script src="slider_common.js"></script>
<script src="slider_core.js"></script>
<script src="slider_events.js"></script>
<script src="slider_methods.js"></script>
<script src="slider_options.js"></script>
<script src="../swarminject.js"></script>
</head>
<body>
<div id="qunit"></div>
<div id="qunit-fixture">
<div id="slider1"></div>
<div id="slider3" style="position: relative; margin: 40px; width: 217px; height: 28px;">
<div class="ui-slider-handle" style="position: absolute; height: 21px; left: 0px; bottom: 0px; width: 17px;"></div>
</div>
</div>
</body>
</html>

23
jquery-ui/tests/unit/slider/slider_common.js vendored Normal file
View file

@ -0,0 +1,23 @@
TestHelpers.commonWidgetTests( "slider", {
defaults: {
animate: false,
cancel: "input,textarea,button,select,option",
delay: 0,
disabled: false,
distance: 0,
max: 100,
min: 0,
orientation: "horizontal",
range: false,
step: 1,
value: 0,
values: null,
// callbacks
create: null,
change: null,
slide: null,
start: null,
stop: null
}
});

297
jquery-ui/tests/unit/slider/slider_core.js vendored Normal file
View file

@ -0,0 +1,297 @@
(function( $ ) {
//
// Slider Test Helper Functions
//
var element, options;
function handle() {
return element.find( ".ui-slider-handle" );
}
// Slider Tests
module( "slider: core" );
test( "keydown HOME on handle sets value to min", function() {
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 } );
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 } );
equal(element.slider( "value" ), options.min) ;
element.slider( "destroy" );
});
test( "keydown END on handle sets value to max", function() {
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 } );
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 } );
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 );
$.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 } );
equal(element.slider( "value" ), 90);
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_UP } );
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 );
$.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 } );
equal(element.slider( "value" ), 10);
handle().simulate( "keydown", { keyCode: $.ui.keyCode.PAGE_DOWN } );
equal(element.slider( "value" ), 0 );
element.slider( "destroy" );
});
});
test( "keydown UP on handle increases value by step, not greater than max", function() {
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 } );
equal(element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
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 } );
equal(element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
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 );
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 } );
equal(element.slider( "value" ), options.max);
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
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 } );
equal(element.slider( "value" ), options.max );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
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 );
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 } );
equal(element.slider( "value" ), options.min);
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
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 } );
equal(element.slider( "value" ), options.min);
handle().simulate( "keydown", { keyCode: $.ui.keyCode.DOWN } );
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 );
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 } );
equal(element.slider( "value" ), options.min );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
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 } );
equal(element.slider( "value" ), options.min );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.LEFT } );
equal(element.slider( "value" ), options.min );
element.slider( "destroy" );
});
})( jQuery );

168
jquery-ui/tests/unit/slider/slider_events.js vendored Normal file
View file

@ -0,0 +1,168 @@
(function( $ ) {
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 );
var element = $( "#slider1" )
.slider({
start: function( event ) {
equal( event.originalEvent.type, "mousedown", "start triggered by mousedown" );
},
slide: function( event) {
equal( event.originalEvent.type, "mousemove", "slider triggered by mousemove" );
},
stop: function( event ) {
equal( event.originalEvent.type, "mouseup", "stop triggered by mouseup" );
},
change: function( event ) {
equal( event.originalEvent.type, "mouseup", "change triggered by mouseup" );
}
});
element.find( ".ui-slider-handle" ).eq( 0 )
.simulate( "drag", { dx: 10, dy: 10 } );
});
test( "keyboard based interaction", function() {
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" );
},
slide: function() {
ok( false, "Slider never triggered by keys" );
},
stop: function( event ) {
equal( event.originalEvent.type, "keyup", "stop triggered by keyup" );
},
change: function( event ) {
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 } );
});
test( "programmatic event triggers", function() {
expect( 6 );
// Test value method
var element = $( "<div></div>" )
.slider({
change: function() {
ok( true, "change triggered by value method" );
}
})
.slider( "value", 0 );
// Test values method
element = $( "<div></div>" )
.slider({
values: [ 10, 20 ],
change: function() {
ok( true, "change triggered by values method" );
}
})
.slider( "values", [ 80, 90 ] );
// Test value option
element = $( "<div></div>" )
.slider({
change: function() {
ok( true, "change triggered by value option" );
}
})
.slider( "option", "value", 0 );
// Test values option
element = $( "<div></div>" )
.slider({
values: [ 10, 20 ],
change: function() {
ok( true, "change triggered by values option" );
}
})
.slider( "option", "values", [ 80, 90 ] );
});
test( "mouse based interaction part two: when handles overlap", function() {
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)" );
}
}),
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 ) {
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 ) {
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 ) {
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 } );
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" );
});
})( jQuery );

163
jquery-ui/tests/unit/slider/slider_methods.js vendored Normal file
View file

@ -0,0 +1,163 @@
(function( $ ) {
module( "slider: methods" );
test( "init", function() {
expect(5);
$( "<div></div>" ).appendTo( "body" ).slider().remove();
ok( true, ".slider() called on element" );
$( [] ).slider().remove();
ok( true, ".slider() called on empty collection" );
$( "<div></div>" ).slider().remove();
ok( true, ".slider() called on disconnected DOMElement" );
var element = $( "<div></div>" ).slider();
element.slider( "option", "foo" );
element.remove();
ok( true, "arbitrary option getter after init" );
$( "<div></div>" ).slider().slider( "option", "foo", "bar" ).remove();
ok( true, "arbitrary option setter after init" );
});
test( "destroy", function() {
expect( 1 );
domEqual( "#slider1", function() {
$( "#slider1" ).slider().slider( "destroy" );
});
});
test( "enable", function() {
expect( 5 );
var element,
expected = $( "<div></div>" ).slider(),
actual = expected.slider( "enable" );
equal(actual, expected, "enable is chainable" );
element = $( "<div></div>" ).slider({ disabled: true });
ok( element.hasClass( "ui-state-disabled" ), "slider has ui-state-disabled class before enable method call" );
ok( element.hasClass( "ui-slider-disabled" ), "slider has ui-slider-disabled class before enable method call" );
element.slider( "enable" );
ok( !element.hasClass( "ui-state-disabled" ), "slider does not have ui-state-disabled class after enable method call" );
ok( !element.hasClass( "ui-slider-disabled" ), "slider does not have ui-slider-disabled class after enable method call" );
});
test( "disable", function() {
expect( 6 );
var element,
expected = $( "<div></div>" ).slider(),
actual = expected.slider( "disable" );
equal(actual, expected, "disable is chainable" );
element = $( "<div></div>" ).slider({ disabled: false });
ok( !element.hasClass( "ui-state-disabled" ), "slider does not have ui-state-disabled class before disabled method call" );
ok( !element.hasClass( "ui-slider-disabled" ), "slider does not have ui-slider-disabled class before disable method call" );
element.slider( "disable" );
ok( element.hasClass( "ui-state-disabled" ), "slider has ui-state-disabled class after disable method call" );
ok( element.hasClass( "ui-slider-disabled" ), "slider has ui-slider-disabled class after disable method call" );
ok( !element.attr( "aria-disabled" ), "slider does not have aria-disabled attr after disable method call" );
});
test( "value", function() {
expect( 19 );
$( [ false, "min", "max" ] ).each(function() {
var element = $( "<div></div>" ).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" );
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 );
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" );
// 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" );
// 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 );
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 );
equal( element.slider( "value" ), 460, "value is restricted to maximum valid step" );
});
test( "values, single step", function() {
expect( 8 );
var element = $( "<div></div>" ).slider( {
range: false,
min: 10,
max: 100,
step: 1,
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" );
element.slider( "values", 0, 5 );
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" );
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" );
element.slider( "values", [ 5, 110 ] );
deepEqual( element.slider( "values" ), [ 10, 100 ], "values - restricted against min and max" );
element.slider( "destroy" );
} );
test( "values, multi step", function() {
expect( 2 );
var element = $( "<div></div>" ).slider( {
range: false,
min: 9,
max: 20,
step: 3,
values: [ 9, 12 ]
} );
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" );
element.slider( "destroy" );
} );
})( jQuery );

364
jquery-ui/tests/unit/slider/slider_options.js vendored Normal file
View file

@ -0,0 +1,364 @@
(function( $ ) {
var element, options;
function handle() {
return element.find( ".ui-slider-handle" );
}
module( "slider: options" );
test( "disabled", function(){
expect( 8 );
var count = 0;
element = $( "#slider1" ).slider();
element.bind( "slidestart", function() {
count++;
});
// enabled
ok( !element.hasClass( "ui-slider-disabled" ), "no disabled class" );
equal( element.slider( "option", "disabled" ), false , "is not disabled" );
handle().simulate( "drag", { dx: 10 } );
equal( count, 1, "slider moved" );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
equal( count, 2, "slider moved" );
// disabled
element.slider( "option", "disabled", true );
ok( element.hasClass( "ui-slider-disabled" ), "has disabled class" );
equal( element.slider( "option", "disabled" ), true, "is disabled" );
handle().simulate( "drag", { dx: 10 } );
equal( count, 2, "slider did not move" );
handle().simulate( "keydown", { keyCode: $.ui.keyCode.RIGHT } );
equal( count, 2, "slider did not move" );
});
test( "max", function() {
expect( 7 );
element = $( "<div></div>" );
options = {
max: 37,
min: 6,
orientation: "horizontal",
step: 1,
value: 50
};
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" );
options = {
max: 9,
min: 1,
orientation: "horizontal",
step: 3,
value: 8.75
};
element.slider( options );
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" );
element.slider( "destroy" );
options = {
max: 60,
min: 50,
orientation: "horizontal",
step: 0.1,
value: 60
};
element.slider( options );
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 );
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" );
element.slider( "destroy" );
} );
test( "min", function() {
expect( 2 );
element = $( "<div></div>" );
options = {
max: 37,
min: 6,
orientation: "vertical",
step: 1,
value: 2
};
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" );
element.slider( "destroy" );
});
test( "orientation", function() {
expect( 8 );
element = $( "#slider1" );
options = {
max: 2,
min: -2,
orientation: "vertical",
value: 1
};
var percentVal = ( options.value - options.min ) / ( options.max - options.min ) * 100;
element.slider( options ).slider( "option", "orientation", "horizontal" );
ok( element.is( ".ui-slider-horizontal" ), "horizontal slider has class .ui-slider-horizontal" );
ok( !element.is( ".ui-slider-vertical" ), "horizontal slider does not have class .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: %" );
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" );
ok( element.is( ".ui-slider-vertical" ), "vertical slider has class .ui-slider-vertical" );
ok( !element.is( ".ui-slider-horizontal" ), "vertical slider does not have class .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: %" );
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)
test( "step", function() {
expect( 9 );
element = $( "<div></div>" ).slider({
min: 0,
value: 0,
step: 10,
max: 100
});
equal( element.slider( "value" ), 0 );
element.slider( "value", 1 );
equal( element.slider( "value" ), 0 );
element.slider( "value", 9 );
equal( element.slider( "value" ), 10 );
element.slider( "value", 11 );
equal( element.slider( "value" ), 10 );
element.slider( "value", 19 );
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 );
equal( element.slider( "value" ), 0 );
element.slider( "option", "value", 9 );
equal( element.slider( "value" ), 0 );
element.slider( "option", "value", 11 );
equal( element.slider( "value" ), 20 );
element.slider( "option", "value", 19 );
equal( element.slider( "value" ), 20 );
element.slider( "destroy" );
});
//test( "value", function() {
// ok(false, "missing test - untested code is broken code." );
//});
test( "values", function() {
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 ]
});
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 );
notEqual(
ranges.eq( 0 ).slider( "values", 0 ),
ranges.eq( 1 ).slider( "values", 0 ),
"the values for multiple sliders should be different"
);
});
test( "range", function() {
expect( 33 );
var range;
// min
element = $( "<div></div>" ).slider({
range: "min",
min: 1,
max: 10,
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" );
element.slider( "destroy" );
// max
element = $( "<div></div>" ).slider({
range: "max",
min: 1,
max: 10,
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" );
element.slider( "destroy" );
// true
element = $( "<div></div>" ).slider({
range: true,
min: 1,
max: 10,
step: 1
});
range = element.find( ".ui-slider-range" );
equal( element.find( ".ui-slider-handle" ).length, 2, "range true, two handles" );
ok( !range.is( ".ui-slider-range-min" ), "range true" );
ok( !range.is( ".ui-slider-range-max" ), "range true" );
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" );
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" );
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" );
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" );
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 );
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" );
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" );
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" );
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 );
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" );
element.slider( "destroy" );
});
})( jQuery );