third-party/jquery-ui-1.10.2/tests/unit/draggable/draggable_options.js

   1 (function( $ ) {
   2
   3 module( "draggable: options" );
   4
   5 // TODO: This doesn't actually test whether append happened, possibly remove
   6 test( "{ appendTo: 'parent' }, default, no clone", function() {
   7         expect( 2 );
   8         var element = $( "#draggable2" ).draggable({ appendTo: "parent" });
   9         TestHelpers.draggable.shouldMove( element );
  10
  11         element = $( "#draggable1" ).draggable({ appendTo: "parent" });
  12         TestHelpers.draggable.shouldMove( element );
  13 });
  14
  15 // TODO: This doesn't actually test whether append happened, possibly remove
  16 test( "{ appendTo: Element }, no clone", function() {
  17         expect( 2 );
  18         var element = $( "#draggable2" ).draggable({ appendTo: $( "#draggable2" ).parent()[ 0 ] });
  19
  20         TestHelpers.draggable.shouldMove( element );
  21
  22         element = $( "#draggable1" ).draggable({ appendTo: $( "#draggable2" ).parent()[ 0 ] });
  23         TestHelpers.draggable.shouldMove( element );
  24 });
  25
  26 // TODO: This doesn't actually test whether append happened, possibly remove
  27 test( "{ appendTo: Selector }, no clone", function() {
  28         expect( 2 );
  29         var element = $( "#draggable2" ).draggable({ appendTo: "#main" });
  30         TestHelpers.draggable.shouldMove( element );
  31
  32         element = $( "#draggable1" ).draggable({ appendTo: "#main" });
  33         TestHelpers.draggable.shouldMove( element );
  34 });
  35
  36 test( "{ appendTo: 'parent' }, default", function() {
  37         expect( 2 );
  38
  39         var element = $( "#draggable1" ).draggable();
  40
  41         TestHelpers.draggable.trackAppendedParent( element );
  42
  43         equal( element.draggable( "option", "appendTo" ), "parent" );
  44
  45         TestHelpers.draggable.move( element, 1, 1 );
  46         equal( element.data( "last_dragged_parent" ), $( "#qunit-fixture" )[ 0 ] );
  47 });
  48
  49 test( "{ appendTo: Element }", function() {
  50         expect( 1 );
  51
  52         var appendTo = $( "#draggable2" ).parent()[ 0 ],
  53                 element = $( "#draggable1" ).draggable({ appendTo: appendTo });
  54
  55         TestHelpers.draggable.trackAppendedParent( element );
  56
  57         TestHelpers.draggable.move( element, 1, 1 );
  58         equal( element.data( "last_dragged_parent" ), appendTo );
  59 });
  60
  61 test( "{ appendTo: jQuery }", function() {
  62         expect( 1 );
  63
  64         var appendTo = $( "#draggable2" ).parent(),
  65                 element = $( "#draggable1" ).draggable({ appendTo: appendTo });
  66
  67         TestHelpers.draggable.trackAppendedParent( element );
  68
  69         TestHelpers.draggable.move( element, 1, 1 );
  70         equal( element.data( "last_dragged_parent" ), appendTo[ 0 ] );
  71 });
  72
  73 test( "{ appendTo: Selector }", function() {
  74         expect( 1 );
  75
  76         var appendTo = "#main",
  77                 element = $( "#draggable1" ).draggable({ appendTo: appendTo });
  78
  79         TestHelpers.draggable.trackAppendedParent( element );
  80
  81         TestHelpers.draggable.move( element, 1, 1 );
  82         equal( element.data( "last_dragged_parent" ), $(appendTo)[ 0 ] );
  83 });
  84
  85 test( "appendTo, default, switching after initialization", function() {
  86         expect( 2 );
  87
  88         var element = $( "#draggable1" ).draggable({ helper : "clone" });
  89
  90         TestHelpers.draggable.trackAppendedParent( element );
  91
  92         // Move and make sure element was appended to fixture
  93         TestHelpers.draggable.move( element, 1, 1 );
  94         equal( element.data( "last_dragged_parent" ), $( "#qunit-fixture" )[ 0 ] );
  95
  96         // Move and make sure element was appended to main
  97         element.draggable( "option", "appendTo", $( "#main" ) );
  98         TestHelpers.draggable.move( element, 2, 2 );
  99         equal( element.data( "last_dragged_parent" ), $( "#main" )[ 0 ] );
 100 });
 101
 102 test( "{ axis: false }, default", function() {
 103         expect( 1 );
 104         var element = $( "#draggable2" ).draggable({ axis: false });
 105         TestHelpers.draggable.shouldMove( element );
 106 });
 107
 108 test( "{ axis: 'x' }", function() {
 109         expect( 1 );
 110         var element = $( "#draggable2" ).draggable({ axis: "x" });
 111         TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 0 );
 112 });
 113
 114 test( "{ axis: 'y' }", function() {
 115         expect( 1 );
 116         var element = $( "#draggable2" ).draggable({ axis: "y" });
 117         TestHelpers.draggable.testDrag( element, element, 50, 50, 0, 50 );
 118 });
 119
 120 test( "{ axis: ? }, unexpected", function() {
 121         var element,
 122                 unexpected = {
 123                         "true": true,
 124                         "{}": {},
 125                         "[]": [],
 126                         "null": null,
 127                         "undefined": undefined,
 128                         "function() {}": function() {}
 129                 };
 130
 131         expect( 6 );
 132
 133         $.each(unexpected, function(key, val) {
 134                 element = $( "#draggable2" ).draggable({ axis: val });
 135                 TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 50, "axis: " + key );
 136                 element.draggable( "destroy" );
 137         });
 138 });
 139
 140 test( "axis, default, switching after initialization", function() {
 141         expect( 3 );
 142
 143         var element = $( "#draggable1" ).draggable({ axis : false });
 144
 145         // Any Direction
 146         TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 50 );
 147
 148         // Only horizontal
 149         element.draggable( "option", "axis", "x" );
 150         TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 0 );
 151
 152         // Vertical only
 153         element.draggable( "option", "axis", "y" );
 154         TestHelpers.draggable.testDrag( element, element, 50, 50, 0, 50 );
 155
 156 });
 157
 158 test( "{ cancel: 'input,textarea,button,select,option' }, default", function() {
 159         expect( 2 );
 160
 161         $( "<div id='draggable-option-cancel-default'><input type='text'></div>" ).appendTo( "#main" );
 162
 163         var element = $( "#draggable-option-cancel-default" ).draggable({ cancel: "input,textarea,button,select,option" });
 164         TestHelpers.draggable.shouldMove( element );
 165
 166         element.draggable( "destroy" );
 167
 168         element = $( "#draggable-option-cancel-default" ).draggable({ cancel: "input,textarea,button,select,option" });
 169         TestHelpers.draggable.testDrag( element, "#draggable-option-cancel-default input", 50, 50, 0, 0 );
 170         element.draggable( "destroy" );
 171 });
 172
 173 test( "{ cancel: 'span' }", function() {
 174         expect( 2 );
 175
 176         var element = $( "#draggable2" ).draggable();
 177         TestHelpers.draggable.testDrag( element, "#draggable2 span", 50, 50, 50, 50 );
 178
 179         element.draggable( "destroy" );
 180
 181         element = $( "#draggable2" ).draggable({ cancel: "span" });
 182         TestHelpers.draggable.testDrag( element, "#draggable2 span", 50, 50, 0, 0 );
 183 });
 184
 185 test( "{ cancel: ? }, unexpected", function() {
 186         expect( 6 );
 187
 188         var element,
 189                 unexpected = {
 190                         "true": true,
 191                         "false": false,
 192                         "{}": {},
 193                         "[]": [],
 194                         "null": null,
 195                         "undefined": undefined
 196                 };
 197
 198         $.each( unexpected, function( key, val ) {
 199                 element = $( "#draggable2" ).draggable({ cancel: val });
 200                 TestHelpers.draggable.shouldMove( element, "cancel: " + key );
 201                 element.draggable( "destroy" );
 202         });
 203 });
 204
 205 /**
 206 test( "{ cancel: Selectors }, matching parent selector", function() {
 207
 208         expect( 5 );
 209
 210         var element = $( "#draggable2" ).draggable({ cancel: "span a" });
 211
 212         $( "#qunit-fixture" ).append( "<span id='wrapping'><a></a></span>" );
 213
 214         element.find( "span" ).append( "<a>" );
 215
 216         $( "#wrapping a" ).append( element );
 217
 218         TestHelpers.draggable.testDrag( element, "#draggable2 span", 50, 50, 50, 50, "drag span child" );
 219         TestHelpers.draggable.shouldNotMove( $( "#draggable2 span a" ) );
 220         TestHelpers.draggable.shouldNotMove( $( "#wrapping a" ) );
 221
 222         $( "#draggable2" ).draggable( "option", "cancel", "span > a" );
 223         $( "#draggable2" ).find( "a" ).append( "<a>" );
 224
 225
 226         TestHelpers.draggable.testDrag( element, $( "#draggable2 span a" ).last(), 50, 50, 50, 50, "drag span child" );
 227         TestHelpers.draggable.shouldNotMove( $( "#draggable2 span a" ).first() );
 228
 229 });
 230 */
 231
 232 test( "cancelement, default, switching after initialization", function() {
 233         expect( 3 );
 234
 235         $( "<div id='draggable-option-cancel-default'><input type='text'></div>" ).appendTo( "#main" );
 236
 237         var input = $( "#draggable-option-cancel-default input" ),
 238                 element = $( "#draggable-option-cancel-default" ).draggable();
 239
 240         TestHelpers.draggable.testDrag( element, input, 50, 50, 0, 0 );
 241
 242         element.draggable( "option", "cancel", "textarea" );
 243         TestHelpers.draggable.testDrag( element, input, 50, 50, 50, 50 );
 244
 245         element.draggable( "option", "cancel", "input" );
 246         TestHelpers.draggable.testDrag( element, input, 50, 50, 0, 0 );
 247 });
 248
 249 /*
 250
 251 test( "{ connectToSortable: selector }, default", function() {
 252         expect( 1 );
 253
 254         ok(false, "missing test - untested code is broken code" );
 255 });
 256 */
 257
 258 test( "{ containment: Element }", function() {
 259         expect( 1 );
 260
 261         var offsetAfter,
 262                 element = $( "#draggable1" ).draggable({ containment: $( "#draggable1" ).parent()[ 0 ] }),
 263                 p = element.parent(),
 264                 po = p.offset(),
 265                 expected = {
 266                         left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ),
 267                         top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" )
 268                 };
 269
 270         element.simulate( "drag", {
 271                 dx: -100,
 272                 dy: -100
 273         });
 274         offsetAfter = element.offset();
 275         deepEqual( offsetAfter, expected, "compare offset to parent" );
 276 });
 277
 278 test( "{ containment: Selector }", function() {
 279         expect( 1 );
 280
 281         var offsetAfter,
 282                 element = $( "#draggable1" ).draggable({ containment: $( "#qunit-fixture" ) }),
 283                 p = element.parent(),
 284                 po = p.offset(),
 285                 expected = {
 286                         left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ),
 287                         top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" )
 288                 };
 289
 290         element.simulate( "drag", {
 291                 dx: -100,
 292                 dy: -100
 293         });
 294         offsetAfter = element.offset();
 295         deepEqual( offsetAfter, expected, "compare offset to parent" );
 296 });
 297
 298 test( "{ containment: [x1, y1, x2, y2] }", function() {
 299         expect( 1 );
 300
 301         var element = $( "#draggable1" ).draggable(),
 302                 eo = element.offset();
 303
 304         element.draggable( "option", "containment", [ eo.left, eo.top, eo.left + element.width() + 5, eo.top + element.height() + 5 ] );
 305
 306         TestHelpers.draggable.testDrag( element, element, -100, -100, 0, 0 );
 307 });
 308
 309 test( "{ containment: 'parent' }, relative", function() {
 310         expect( 1 );
 311
 312         var offsetAfter,
 313                 element = $( "#draggable1" ).draggable({ containment: "parent" }),
 314                 p = element.parent(),
 315                 po = p.offset(),
 316                 expected = {
 317                         left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ),
 318                         top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" )
 319                 };
 320
 321         element.simulate( "drag", {
 322                 dx: -100,
 323                 dy: -100
 324         });
 325         offsetAfter = element.offset();
 326         deepEqual( offsetAfter, expected, "compare offset to parent" );
 327 });
 328
 329 test( "{ containment: 'parent' }, absolute", function() {
 330         expect( 1 );
 331
 332         var offsetAfter,
 333                 element = $( "#draggable2" ).draggable({ containment: "parent" }),
 334                 p = element.parent(),
 335                 po = p.offset(),
 336                 expected = {
 337                         left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ),
 338                         top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" )
 339                 };
 340
 341         element.simulate( "drag", {
 342                 dx: -100,
 343                 dy: -100
 344         });
 345         offsetAfter = element.offset();
 346         deepEqual( offsetAfter, expected, "compare offset to parent" );
 347 });
 348
 349 test( "containment, account for border", function() {
 350         expect( 2 );
 351
 352         var el = $("#draggable1").appendTo("#main"),
 353                 parent = el.parent().css({
 354                         height: "100px",
 355                         width: "100px",
 356                         borderStyle: "solid",
 357                         borderWidth: "5px 10px 15px 20px"
 358                 }),
 359                 parentBottom = parent.offset().top + parent.outerHeight(),
 360                 parentRight = parent.offset().left + parent.outerWidth(),
 361                 parentBorderBottom = TestHelpers.draggable.border( parent, "bottom" ),
 362                 parentBorderRight = TestHelpers.draggable.border( parent, "right" );
 363
 364         el.css({
 365                 height: "5px",
 366                 width: "5px"
 367         }).draggable({ containment: "parent" });
 368
 369         el.simulate( "drag", {
 370                 dx: 100,
 371                 dy: 100
 372         });
 373
 374         equal( el.offset().top, parentBottom - parentBorderBottom - el.height(),
 375                 "The draggable should be on top of its parent's bottom border" );
 376         equal( el.offset().left, parentRight - parentBorderRight - el.width(),
 377                 "The draggable should be to the right of its parent's right border" );
 378 });
 379
 380 test( "containment, default, switching after initialization", function() {
 381         expect( 2 );
 382
 383         var element = $( "#draggable1" ).draggable({ containment: false });
 384
 385         TestHelpers.draggable.testDrag( element, element, -100, -100, -100, -100 );
 386
 387         element.draggable( "option", "containment", "parent" )
 388                 .css({
 389                         top: 0,
 390                         left: 0
 391                 })
 392                 .appendTo( $( "#main" ) );
 393
 394         TestHelpers.draggable.testDrag( element, element, -100, -100, 0, 0 );
 395
 396         // TODO: Switching back to false does not update to false
 397         // element.draggable( "option", "containment", false );
 398         // TestHelpers.draggable.testDrag( element, element, -100, -100, -100, -100 );
 399 });
 400
 401 test( "{ cursor: 'auto' }, default", function() {
 402         function getCursor() {
 403                 return $( "#draggable2" ).css( "cursor" );
 404         }
 405
 406         expect( 2 );
 407
 408         var actual, after,
 409                 expected = "auto",
 410                 element = $( "#draggable2" ).draggable({
 411                         cursor: expected,
 412                         start: function() {
 413                                 actual = getCursor();
 414                         }
 415                 }),
 416                 before = getCursor();
 417
 418         element.simulate( "drag", {
 419                 dx: -1,
 420                 dy: -1
 421         });
 422         after = getCursor();
 423
 424         equal( actual, expected, "start callback: cursor '" + expected + "'" );
 425         equal( after, before, "after drag: cursor restored" );
 426 });
 427
 428 test( "{ cursor: 'move' }", function() {
 429         function getCursor() {
 430                 return $( "body" ).css( "cursor" );
 431         }
 432
 433         expect( 2 );
 434
 435         var actual, after,
 436                 expected = "move",
 437                 element = $( "#draggable2" ).draggable({
 438                         cursor: expected,
 439                         start: function() {
 440                                 actual = getCursor();
 441                         }
 442                 }),
 443                 before = getCursor();
 444
 445         element.simulate( "drag", {
 446                 dx: -1,
 447                 dy: -1
 448         });
 449         after = getCursor();
 450
 451         equal( actual, expected, "start callback: cursor '" + expected + "'" );
 452         equal( after, before, "after drag: cursor restored" );
 453 });
 454
 455 test( "cursor, default, switching after initialization", function() {
 456         expect( 3 );
 457
 458         var element = $( "#draggable1" ).draggable();
 459
 460         TestHelpers.draggable.trackMouseCss( element );
 461
 462         TestHelpers.draggable.move( element, 1, 1 );
 463         equal( element.data( "last_dragged_cursor" ), "auto" );
 464
 465         element.draggable( "option", "cursor", "move" );
 466         TestHelpers.draggable.move( element, 1, 1 );
 467         equal( element.data( "last_dragged_cursor" ), "move" );
 468
 469         element.draggable( "option", "cursor", "ns-resize" );
 470         TestHelpers.draggable.move( element, 1, 1 );
 471         equal( element.data( "last_dragged_cursor" ), "ns-resize" );
 472 });
 473
 474 test( "cursorAt", function() {
 475         expect( 24 );
 476
 477         var deltaX = -3,
 478                 deltaY = -3,
 479                 tests = {
 480                         "false": { cursorAt : false },
 481                         "{ left: -5, top: -5 }": { x: -5, y: -5, cursorAt : { left: -5, top: -5 } },
 482                         "[ 10, 20 ]": { x: 10, y: 20, cursorAt : [ 10, 20 ] },
 483                         "'10 20'": { x: 10, y: 20, cursorAt : "10 20" },
 484                         "{ left: 20, top: 40 }": { x: 20, y: 40, cursorAt : { left: 20, top: 40 } },
 485                         "{ right: 10, bottom: 20 }": { x: 10, y: 20, cursorAt : { right: 10, bottom: 20 } }
 486                 };
 487
 488         $.each( tests, function( testName, testData ) {
 489                 $.each( [ "relative", "absolute" ], function( i, position ) {
 490                         var element = $( "#draggable" + ( i + 1 ) ).draggable({
 491                                         cursorAt: testData.cursorAt,
 492                                         drag: function( event, ui ) {
 493                                                 if( !testData.cursorAt ) {
 494                                                         equal( ui.position.left - ui.originalPosition.left, deltaX, testName + " " + position + " left" );
 495                                                         equal( ui.position.top - ui.originalPosition.top, deltaY, testName + " " + position + " top" );
 496                                                 } else if( testData.cursorAt.right ) {
 497                                                         equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" );
 498                                                         equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - TestHelpers.draggable.unreliableOffset, testName + " " +position + " top" );
 499                                                 } else {
 500                                                         equal( event.clientX - ui.offset.left, testData.x + TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" );
 501                                                         equal( event.clientY - ui.offset.top, testData.y + TestHelpers.draggable.unreliableOffset, testName + " " + position + " top" );
 502                                                 }
 503                                         }
 504                         });
 505
 506                         element.simulate( "drag", {
 507                                 moves: 1,
 508                                 dx: deltaX,
 509                                 dy: deltaY
 510                         });
 511                 });
 512         });
 513 });
 514
 515 test( "cursorAt, switching after initialization", function() {
 516         expect( 24 );
 517
 518         var deltaX = -3,
 519                 deltaY = -3,
 520                 tests = {
 521                         "false": { cursorAt : false },
 522                         "{ left: -5, top: -5 }": { x: -5, y: -5, cursorAt : { left: -5, top: -5 } },
 523                         "[ 10, 20 ]": { x: 10, y: 20, cursorAt : [ 10, 20 ] },
 524                         "'10 20'": { x: 10, y: 20, cursorAt : "10 20" },
 525                         "{ left: 20, top: 40 }": { x: 20, y: 40, cursorAt : { left: 20, top: 40 } },
 526                         "{ right: 10, bottom: 20 }": { x: 10, y: 20, cursorAt : { right: 10, bottom: 20 } }
 527                 };
 528
 529         $.each( tests, function( testName, testData ) {
 530                 $.each( [ "relative", "absolute" ], function( i, position ) {
 531                         var element = $( "#draggable" + ( i + 1 ) );
 532
 533                         element.draggable({
 534                                         drag: function( event, ui ) {
 535                                                 if( !testData.cursorAt ) {
 536                                                         equal( ui.position.left - ui.originalPosition.left, deltaX, testName + " " + position + " left" );
 537                                                         equal( ui.position.top - ui.originalPosition.top, deltaY, testName + " " + position + " top" );
 538                                                 } else if( testData.cursorAt.right ) {
 539                                                         equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" );
 540                                                         equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - TestHelpers.draggable.unreliableOffset, testName + " " +position + " top" );
 541                                                 } else {
 542                                                         equal( event.clientX - ui.offset.left, testData.x + TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" );
 543                                                         equal( event.clientY - ui.offset.top, testData.y + TestHelpers.draggable.unreliableOffset, testName + " " + position + " top" );
 544                                                 }
 545                                         }
 546                         });
 547
 548                         element.draggable( "option", "cursorAt", false );
 549                         element.draggable( "option", "cursorAt", testData.cursorAt );
 550
 551                         element.simulate( "drag", {
 552                                 moves: 1,
 553                                 dx: deltaX,
 554                                 dy: deltaY
 555                         });
 556                 });
 557         });
 558 });
 559
 560 test( "disabled", function() {
 561         expect( 3 );
 562
 563         var element = $( "#draggable1" ).draggable();
 564
 565         TestHelpers.draggable.shouldMove( element );
 566
 567         element.draggable( "option", "disabled", true );
 568         TestHelpers.draggable.shouldNotMove( element );
 569
 570         element.draggable( "option", "disabled", false );
 571         TestHelpers.draggable.shouldMove( element );
 572 });
 573
 574 test( "{ grid: [50, 50] }, relative", function() {
 575         expect( 2 );
 576
 577         var element = $( "#draggable1" ).draggable({ grid: [ 50, 50 ] });
 578         TestHelpers.draggable.testDrag( element, element, 24, 24, 0, 0 );
 579         TestHelpers.draggable.testDrag( element, element, 26, 25, 50, 50 );
 580 });
 581
 582 test( "{ grid: [50, 50] }, absolute", function() {
 583         expect( 2 );
 584
 585         var element = $( "#draggable2" ).draggable({ grid: [ 50, 50 ] });
 586         TestHelpers.draggable.testDrag( element, element, 24, 24, 0, 0 );
 587         TestHelpers.draggable.testDrag( element, element, 26, 25, 50, 50 );
 588 });
 589
 590 test( "grid, switching after initialization", function() {
 591         expect( 4 );
 592
 593         var element = $( "#draggable1" ).draggable();
 594
 595         // Forward
 596         TestHelpers.draggable.testDrag( element, element, 24, 24, 24, 24 );
 597         TestHelpers.draggable.testDrag( element, element, 0, 0, 0, 0 );
 598
 599         element.draggable( "option", "grid", [ 50,50 ] );
 600
 601         TestHelpers.draggable.testDrag( element, element, 24, 24, 0, 0 );
 602         TestHelpers.draggable.testDrag( element, element, 26, 25, 50, 50 );
 603 });
 604
 605 test( "{ handle: 'span' }", function() {
 606         expect( 3 );
 607
 608         var element = $( "#draggable2" ).draggable({ handle: "span" });
 609
 610         TestHelpers.draggable.testDrag( element, "#draggable2 span", 50, 50, 50, 50, "drag span" );
 611         TestHelpers.draggable.testDrag( element, "#draggable2 span em", 50, 50, 50, 50, "drag span child" );
 612         TestHelpers.draggable.shouldNotMove( element, "drag element" );
 613 });
 614
 615 test( "handle, default, switching after initialization", function() {
 616         expect( 6 );
 617
 618         var element = $( "#draggable2" ).draggable();
 619
 620         TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 50 );
 621         TestHelpers.draggable.testDrag( element, "#draggable2 span", 100, 100, 100, 100 );
 622
 623         // Switch
 624         element.draggable( "option", "handle", "span" );
 625         TestHelpers.draggable.testDrag( element, element, 50, 50, 0, 0 );
 626         TestHelpers.draggable.testDrag( element, "#draggable2 span", 100, 100, 100, 100 );
 627
 628         // And back
 629         element.draggable( "option", "handle", false );
 630         TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 50 );
 631         TestHelpers.draggable.testDrag( element, "#draggable2 span", 100, 100, 100, 100 );
 632 });
 633
 634 test( "helper, default, switching after initialization", function() {
 635         expect( 3 );
 636
 637         var element = $( "#draggable1" ).draggable();
 638         TestHelpers.draggable.shouldMove( element );
 639
 640         element.draggable( "option", "helper", "clone" );
 641         TestHelpers.draggable.shouldNotMove( element );
 642
 643         element.draggable( "option", "helper", "original" );
 644         TestHelpers.draggable.shouldMove( element );
 645 });
 646
 647 test( "{ helper: 'clone' }, relative", function() {
 648         expect( 1 );
 649
 650         var element = $( "#draggable1" ).draggable({ helper: "clone" });
 651         TestHelpers.draggable.shouldNotMove( element );
 652 });
 653
 654 test( "{ helper: 'clone' }, absolute", function() {
 655         expect( 1 );
 656
 657         var element = $( "#draggable2" ).draggable({ helper: "clone" });
 658         TestHelpers.draggable.shouldNotMove( element );
 659 });
 660
 661 test( "{ helper: 'original' }, relative, with scroll offset on parent", function() {
 662         expect( 3 );
 663
 664         var element = $( "#draggable1" ).draggable({ helper: "original" });
 665
 666         TestHelpers.draggable.setScroll();
 667         TestHelpers.draggable.testScroll( element, "relative" );
 668
 669         TestHelpers.draggable.setScroll();
 670         TestHelpers.draggable.testScroll( element, "static" );
 671
 672         TestHelpers.draggable.setScroll();
 673         TestHelpers.draggable.testScroll( element, "absolute" );
 674
 675         TestHelpers.draggable.restoreScroll();
 676 });
 677
 678 test( "{ helper: 'original' }, relative, with scroll offset on root", function() {
 679         expect( 3 );
 680
 681         var element = $( "#draggable1" ).draggable({ helper: "original" });
 682
 683         TestHelpers.draggable.setScroll( "root" );
 684         TestHelpers.draggable.testScroll( element, "relative" );
 685
 686         TestHelpers.draggable.setScroll( "root" );
 687         TestHelpers.draggable.testScroll( element, "static" );
 688
 689         TestHelpers.draggable.setScroll( "root" );
 690         TestHelpers.draggable.testScroll( element, "absolute" );
 691
 692         TestHelpers.draggable.restoreScroll( "root" );
 693 });
 694
 695 test( "{ helper: 'original' }, relative, with scroll offset on root and parent", function() {
 696         expect( 3 );
 697
 698         var element = $( "#draggable1" ).draggable({ helper: "original" });
 699
 700         TestHelpers.draggable.setScroll();
 701         TestHelpers.draggable.setScroll( "root" );
 702         TestHelpers.draggable.testScroll( element, "relative" );
 703
 704         TestHelpers.draggable.setScroll();
 705         TestHelpers.draggable.setScroll( "root" );
 706         TestHelpers.draggable.testScroll( element, "static" );
 707
 708         TestHelpers.draggable.setScroll();
 709         TestHelpers.draggable.setScroll( "root" );
 710         TestHelpers.draggable.testScroll( element, "absolute" );
 711
 712         TestHelpers.draggable.restoreScroll();
 713         TestHelpers.draggable.restoreScroll( "root" );
 714 });
 715
 716 test( "{ helper: 'original' }, absolute, with scroll offset on parent", function() {
 717         expect( 3 );
 718
 719         var element = $( "#draggable1" ).css({ position: "absolute", top: 0, left: 0 }).draggable({ helper: "original" });
 720
 721         TestHelpers.draggable.setScroll();
 722         TestHelpers.draggable.testScroll( element, "relative" );
 723
 724         TestHelpers.draggable.setScroll();
 725         TestHelpers.draggable.testScroll( element, "static" );
 726
 727         TestHelpers.draggable.setScroll();
 728         TestHelpers.draggable.testScroll( element, "absolute" );
 729
 730         TestHelpers.draggable.restoreScroll();
 731 });
 732
 733 test( "{ helper: 'original' }, absolute, with scroll offset on root", function() {
 734         expect( 3 );
 735
 736         var element = $( "#draggable1" ).css({ position: "absolute", top: 0, left: 0 }).draggable({ helper: "original" });
 737
 738         TestHelpers.draggable.setScroll( "root" );
 739         TestHelpers.draggable.testScroll( element, "relative" );
 740
 741         TestHelpers.draggable.setScroll( "root" );
 742         TestHelpers.draggable.testScroll( element, "static" );
 743
 744         TestHelpers.draggable.setScroll( "root" );
 745         TestHelpers.draggable.testScroll( element, "absolute" );
 746
 747         TestHelpers.draggable.restoreScroll( "root" );
 748 });
 749
 750 test( "{ helper: 'original' }, absolute, with scroll offset on root and parent", function() {
 751         expect( 3 );
 752
 753         var element = $( "#draggable1" ).css({ position: "absolute", top: 0, left: 0 }).draggable({ helper: "original" });
 754
 755         TestHelpers.draggable.setScroll();
 756         TestHelpers.draggable.setScroll( "root" );
 757         TestHelpers.draggable.testScroll( element, "relative" );
 758
 759         TestHelpers.draggable.setScroll();
 760         TestHelpers.draggable.setScroll( "root" );
 761         TestHelpers.draggable.testScroll( element, "static" );
 762
 763         TestHelpers.draggable.setScroll();
 764         TestHelpers.draggable.setScroll( "root" );
 765         TestHelpers.draggable.testScroll( element, "absolute" );
 766
 767         TestHelpers.draggable.restoreScroll();
 768         TestHelpers.draggable.restoreScroll( "root" );
 769 });
 770
 771 test( "{ helper: 'original' }, fixed, with scroll offset on parent", function() {
 772         expect( 3 );
 773
 774         var element = $( "#draggable1" ).css({ position: "fixed", top: 0, left: 0 }).draggable({ helper: "original" });
 775
 776         TestHelpers.draggable.setScroll();
 777         TestHelpers.draggable.testScroll( element, "relative" );
 778
 779         TestHelpers.draggable.setScroll();
 780         TestHelpers.draggable.testScroll( element, "static" );
 781
 782         TestHelpers.draggable.setScroll();
 783         TestHelpers.draggable.testScroll( element, "absolute" );
 784
 785         TestHelpers.draggable.restoreScroll();
 786 });
 787
 788 test( "{ helper: 'original' }, fixed, with scroll offset on root", function() {
 789         expect( 3 );
 790
 791         var element = $( "#draggable1" ).css({ position: "fixed", top: 0, left: 0 }).draggable({ helper: "original" });
 792
 793         TestHelpers.draggable.setScroll( "root" );
 794         TestHelpers.draggable.testScroll( element, "relative" );
 795
 796         TestHelpers.draggable.setScroll( "root" );
 797         TestHelpers.draggable.testScroll( element, "static" );
 798
 799         TestHelpers.draggable.setScroll( "root" );
 800         TestHelpers.draggable.testScroll( element, "absolute" );
 801
 802         TestHelpers.draggable.restoreScroll( "root" );
 803 });
 804
 805 test( "{ helper: 'original' }, fixed, with scroll offset on root and parent", function() {
 806         expect( 3 );
 807
 808         var element = $( "#draggable1" ).css({ position: "fixed", top: 0, left: 0 }).draggable({ helper: "original" });
 809
 810         TestHelpers.draggable.setScroll();
 811         TestHelpers.draggable.setScroll( "root" );
 812         TestHelpers.draggable.testScroll( element, "relative" );
 813
 814         TestHelpers.draggable.setScroll();
 815         TestHelpers.draggable.setScroll( "root" );
 816         TestHelpers.draggable.testScroll( element, "static" );
 817
 818         TestHelpers.draggable.setScroll();
 819         TestHelpers.draggable.setScroll( "root" );
 820         TestHelpers.draggable.testScroll( element, "absolute" );
 821
 822         TestHelpers.draggable.restoreScroll();
 823         TestHelpers.draggable.restoreScroll( "root" );
 824 });
 825
 826 test( "{ helper: 'clone' }, absolute", function() {
 827         expect( 1 );
 828
 829         var helperOffset = null,
 830                 origOffset = $( "#draggable1" ).offset(),
 831                 element = $( "#draggable1" ).draggable({ helper: "clone", drag: function( event, ui) {
 832                         helperOffset = ui.helper.offset();
 833                 } });
 834
 835         element.simulate( "drag", {
 836                 dx: 1,
 837                 dy: 1
 838         });
 839         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 840 });
 841
 842 test( "{ helper: 'clone' }, absolute with scroll offset on parent", function() {
 843         expect( 3 );
 844
 845         TestHelpers.draggable.setScroll();
 846         var helperOffset = null,
 847                 origOffset = null,
 848                 element = $( "#draggable1" ).draggable({
 849                         helper: "clone",
 850                         drag: function( event, ui) {
 851                                 helperOffset = ui.helper.offset();
 852                         }
 853                 });
 854
 855         $( "#main" ).css( "position", "relative" );
 856         origOffset = $( "#draggable1" ).offset();
 857         element.simulate( "drag", {
 858                 dx: 1,
 859                 dy: 1
 860         });
 861         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 862
 863         $( "#main" ).css( "position", "static" );
 864         origOffset = $( "#draggable1" ).offset();
 865         element.simulate( "drag", {
 866                 dx: 1,
 867                 dy: 1
 868         });
 869         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 870
 871         $( "#main" ).css( "position", "absolute" );
 872         origOffset = $( "#draggable1" ).offset();
 873         element.simulate( "drag", {
 874                 dx: 1,
 875                 dy: 1
 876         });
 877         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 878
 879         TestHelpers.draggable.restoreScroll();
 880 });
 881
 882 test( "{ helper: 'clone' }, absolute with scroll offset on root", function() {
 883         expect( 3 );
 884
 885         TestHelpers.draggable.setScroll( "root" );
 886         var helperOffset = null,
 887                 origOffset = null,
 888                 element = $( "#draggable1" ).draggable({
 889                         helper: "clone",
 890                         drag: function( event, ui) {
 891                                 helperOffset = ui.helper.offset();
 892                         }
 893                 });
 894
 895         $( "#main" ).css( "position", "relative" );
 896         origOffset = $( "#draggable1" ).offset();
 897         element.simulate( "drag", {
 898                 dx: 1,
 899                 dy: 1
 900         });
 901         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 902
 903         $( "#main" ).css( "position", "static" );
 904         origOffset = $( "#draggable1" ).offset();
 905         element.simulate( "drag", {
 906                 dx: 1,
 907                 dy: 1
 908         });
 909         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 910
 911         $( "#main" ).css( "position", "absolute" );
 912         origOffset = $( "#draggable1" ).offset();
 913         element.simulate( "drag", {
 914                 dx: 1,
 915                 dy: 1
 916         });
 917         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 918
 919         TestHelpers.draggable.restoreScroll( "root" );
 920 });
 921
 922 test( "{ helper: 'clone' }, absolute with scroll offset on root and parent", function() {
 923         expect( 3 );
 924
 925         TestHelpers.draggable.setScroll( "root" );
 926         TestHelpers.draggable.setScroll();
 927
 928         var helperOffset = null,
 929                 origOffset = null,
 930                 element = $( "#draggable1" ).draggable({
 931                         helper: "clone",
 932                         drag: function( event, ui) {
 933                                 helperOffset = ui.helper.offset();
 934                         }
 935                 });
 936
 937         $( "#main" ).css( "position", "relative" );
 938         origOffset = $( "#draggable1" ).offset();
 939         element.simulate( "drag", {
 940                 dx: 1,
 941                 dy: 1
 942         });
 943         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 944
 945         $( "#main" ).css( "position", "static" );
 946         origOffset = $( "#draggable1" ).offset();
 947         element.simulate( "drag", {
 948                 dx: 1,
 949                 dy: 1
 950         });
 951         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 952
 953         $( "#main" ).css( "position", "absolute" );
 954         origOffset = $( "#draggable1" ).offset();
 955         element.simulate( "drag", {
 956                 dx: 1,
 957                 dy: 1
 958         });
 959         deepEqual({ top: helperOffset.top - 1, left: helperOffset.left - 1 }, origOffset, "dragged[1, 1]" );
 960
 961         TestHelpers.draggable.restoreScroll( "root" );
 962         TestHelpers.draggable.restoreScroll();
 963 });
 964
 965 test( "{ opacity: 0.5 }", function() {
 966         expect( 1 );
 967
 968         var opacity = null,
 969                 element = $( "#draggable2" ).draggable({
 970                         opacity: 0.5,
 971                         start: function() {
 972                                 opacity = $(this).css( "opacity" );
 973                         }
 974                 });
 975
 976         element.simulate( "drag", {
 977                 dx: -1,
 978                 dy: -1
 979         });
 980
 981         equal( opacity, 0.5, "start callback: opacity is" );
 982 });
 983
 984 test( "opacity, default, switching after initialization", function() {
 985         expect( 3 );
 986
 987         var opacity = null,
 988                 element = $( "#draggable2" ).draggable({
 989                         start: function() {
 990                                 opacity = $(this).css( "opacity" );
 991                         }
 992                 });
 993
 994         TestHelpers.draggable.move( element, 1, 1 );
 995         equal( opacity, 1 );
 996
 997         element.draggable( "option", "opacity", 0.5 );
 998         TestHelpers.draggable.move( element, 2, 1 );
 999         equal( opacity, 0.5 );
1000
1001         element.draggable( "option", "opacity", false );
1002         TestHelpers.draggable.move( element, 3, 1 );
1003         equal( opacity, 1 );
1004 });
1005
1006 asyncTest( "revert and revertDuration", function() {
1007         expect( 4 );
1008
1009         var element = $( "#draggable2" ).draggable({
1010                 revert: true,
1011                 revertDuration: 0
1012         });
1013         TestHelpers.draggable.shouldNotMove( element, "revert: true, revertDuration: 0 should revert immediately" );
1014
1015         $( "#draggable2" ).draggable( "option", "revert", "invalid" );
1016         TestHelpers.draggable.shouldNotMove( element, "revert: invalid, revertDuration: 0 should revert immediately" );
1017
1018         $( "#draggable2" ).draggable( "option", "revert", false );
1019         TestHelpers.draggable.shouldMove( element, "revert: false should allow movement" );
1020
1021         $( "#draggable2" ).draggable( "option", {
1022                 revert: true,
1023                 revertDuration: 200,
1024                 stop: function() {
1025                         start();
1026                 }
1027         });
1028
1029         // animation are async, so test for it asynchronously
1030         TestHelpers.draggable.move( element, 50, 50 );
1031         setTimeout( function() {
1032                 ok( $( "#draggable2" ).is( ":animated" ), "revert: true with revertDuration should animate" );
1033         });
1034 });
1035
1036 test( "revert: valid", function() {
1037         expect( 1 );
1038
1039         var element = $( "#draggable2" ).draggable({
1040                         revert: "valid",
1041                         revertDuration: 0
1042                 });
1043
1044         $( "#droppable" ).droppable();
1045
1046         TestHelpers.draggable.testDrag( element, element, 100, 100, 0, 0, "revert: valid reverts when dropped on a droppable" );
1047 });
1048
1049 test( "scope", function() {
1050         expect( 2 );
1051
1052         var element = $( "#draggable2" ).draggable({
1053                 scope: "tasks",
1054                 revert: "valid",
1055                 revertDuration: 0
1056         });
1057
1058         $( "#droppable" ).droppable({ scope: "tasks" });
1059
1060         TestHelpers.draggable.testDrag( element, element, 100, 100, 0, 0, "revert: valid reverts when dropped on a droppable" );
1061
1062         $( "#droppable" ).droppable( "destroy" ).droppable({ scope: "nottasks" });
1063
1064         TestHelpers.draggable.testDrag( element, element, 100, 100, 100, 100, "revert: valid reverts when dropped on a droppable" );
1065 });
1066
1067 test( "scroll, scrollSensitivity, and scrollSpeed", function() {
1068         expect( 2 );
1069
1070         var viewportHeight = $( window ).height(),
1071                 element = $( "#draggable1" ).draggable({ scroll: true }),
1072                 scrollSensitivity = element.draggable( "option", "scrollSensitivity" ),
1073                 scrollSpeed = element.draggable( "option", "scrollSpeed" );
1074
1075         element.offset({
1076                 top: viewportHeight - scrollSensitivity - 1,
1077                 left: 1
1078         });
1079
1080         element.simulate( "drag", {
1081                 dx: 1,
1082                 y: viewportHeight - scrollSensitivity - 1,
1083                 moves: 1
1084         });
1085
1086         ok( $( window ).scrollTop() === 0, "scroll: true doesn't scroll when the element is dragged outside of scrollSensitivity" );
1087
1088         element.draggable( "option", "scrollSensitivity", scrollSensitivity + 10 );
1089
1090         element.offset({
1091                 top: viewportHeight - scrollSensitivity - 1,
1092                 left: 1
1093         });
1094
1095         element.simulate( "drag", {
1096                 dx: 1,
1097                 y: viewportHeight - scrollSensitivity - 1,
1098                 moves: 1
1099         });
1100
1101         ok( $( window ).scrollTop() === scrollSpeed, "scroll: true scrolls when the element is dragged within scrollSensitivity" );
1102
1103         TestHelpers.draggable.restoreScroll( document );
1104 });
1105
1106 test( "snap, snapMode, and snapTolerance", function() {
1107         expect( 9 );
1108
1109         var newX, newY,
1110                 snapTolerance = 15,
1111                 element = $( "#draggable1" ).draggable({
1112                         snap: true,
1113                         snapMode: "both",
1114                         snapTolerance: snapTolerance
1115                 }),
1116                 element2 = $( "#draggable2" ).draggable();
1117
1118         element.offset({
1119                 top: 1,
1120                 left: 1
1121         });
1122
1123         newX = element2.offset().left - element.outerWidth() - snapTolerance - 2;
1124         newY = element2.offset().top;
1125
1126         element.simulate( "drag", {
1127                 handle: "corner",
1128                 x: newX,
1129                 y: newY,
1130                 moves: 1
1131         });
1132
1133         deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap outside the snapTolerance" );
1134
1135         newX += 3;
1136
1137         element.simulate( "drag", {
1138                 handle: "corner",
1139                 x: newX,
1140                 y: newY,
1141                 moves: 1
1142         });
1143
1144         notDeepEqual( element.offset(), { top: newY, left: newX }, "snaps inside the snapTolerance" );
1145
1146         element.draggable( "option", "snap", "#draggable2" );
1147
1148         element.simulate( "drag", {
1149                 handle: "corner",
1150                 x: newX,
1151                 y: newY,
1152                 moves: 1
1153         });
1154
1155         notDeepEqual( element.offset(), { top: newY, left: newX }, "snaps based on selector" );
1156
1157         element.draggable( "option", "snap", "#draggable3" );
1158
1159         element.simulate( "drag", {
1160                 handle: "corner",
1161                 x: newX,
1162                 y: newY,
1163                 moves: 1
1164         });
1165
1166         deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap based on invalid selector" );
1167
1168         element.draggable( "option", "snap", true );
1169         element.draggable( "option", "snapTolerance", snapTolerance - 2 );
1170         element.simulate( "drag", {
1171                 handle: "corner",
1172                 x: newX,
1173                 y: newY,
1174                 moves: 1
1175         });
1176
1177         deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap outside the modified snapTolerance" );
1178
1179         element.draggable( "option", "snapTolerance", snapTolerance );
1180         element.draggable( "option", "snapMode", "inner" );
1181
1182         element.simulate( "drag", {
1183                 handle: "corner",
1184                 x: newX,
1185                 y: newY,
1186                 moves: 1
1187         });
1188
1189         deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap inside the outer snapTolerance area when snapMode is inner" );
1190
1191         newX = element2.offset().left - snapTolerance - 1;
1192         newY = element2.offset().top;
1193
1194         element.simulate( "drag", {
1195                 handle: "corner",
1196                 x: newX,
1197                 y: newY,
1198                 moves: 1
1199         });
1200
1201         deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap inside the outer snapTolerance area when snapMode is inner" );
1202
1203         newX++;
1204
1205         element.simulate( "drag", {
1206                 handle: "corner",
1207                 x: newX,
1208                 y: newY,
1209                 moves: 1
1210         });
1211
1212         notDeepEqual( element.offset(), { top: newY, left: newX }, "snaps inside the inner snapTolerance area when snapMode is inner" );
1213
1214         element.draggable( "option", "snapMode", "outer" );
1215
1216         element.simulate( "drag", {
1217                 handle: "corner",
1218                 x: newX,
1219                 y: newY,
1220                 moves: 1
1221         });
1222
1223         deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap on the inner snapTolerance area when snapMode is outer" );
1224 });
1225
1226 test( "stack", function() {
1227         expect( 2 );
1228
1229         var element = $( "#draggable1" ).draggable({
1230                         stack: "#draggable1, #draggable2"
1231                 }),
1232                 element2 = $( "#draggable2" ).draggable({
1233                         stack: "#draggable1, #draggable2"
1234                 });
1235
1236         TestHelpers.draggable.move( element, 1, 1 );
1237         equal( element.css( "zIndex" ), "2", "stack increments zIndex correctly" );
1238
1239         TestHelpers.draggable.move( element2, 1, 1 );
1240         equal( element2.css( "zIndex" ), "3", "stack increments zIndex correctly" );
1241 });
1242
1243 test( "{ zIndex: 10 }", function() {
1244         expect( 1 );
1245
1246         var actual,
1247                 expected = 10,
1248                 element = $( "#draggable2" ).draggable({
1249                         zIndex: expected,
1250                         start: function() {
1251                                 actual = $(this).css( "zIndex" );
1252                         }
1253                 });
1254
1255         element.simulate( "drag", {
1256                 dx: -1,
1257                 dy: -1
1258         });
1259
1260         equal( actual, expected, "start callback: zIndex is" );
1261
1262 });
1263
1264 test( "zIndex, default, switching after initialization", function() {
1265
1266         expect( 3 );
1267
1268         var zindex = null,
1269                 element = $( "#draggable2" ).draggable({
1270                         start: function() {
1271                                 zindex = $(this).css( "z-index" );
1272                         }
1273                 });
1274
1275         element.css( "z-index", 1 );
1276
1277         TestHelpers.draggable.move( element, 1, 1 );
1278         equal( zindex, 1 );
1279
1280         element.draggable( "option", "zIndex", 5 );
1281         TestHelpers.draggable.move( element, 2, 1 );
1282         equal( zindex, 5 );
1283
1284         element.draggable( "option", "zIndex", false );
1285         TestHelpers.draggable.move( element, 3, 1 );
1286         equal( zindex, 1 );
1287
1288 });
1289
1290 })( jQuery );