corrade-http-templates

Subversion Repositories:

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

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/common.js
@@ -0,0 +1,31 @@
+define( [
+        "lib/common",
+        "ui/widgets/tabs"
+], function( common ) {
+common.testWidget( "tabs", {
+        defaults: {
+                active: null,
+                classes: {
+                        "ui-tabs": "ui-corner-all",
+                        "ui-tabs-nav": "ui-corner-all",
+                        "ui-tabs-panel": "ui-corner-bottom",
+                        "ui-tabs-tab": "ui-corner-top"
+                },
+                collapsible: false,
+                disabled: false,
+                event: "click",
+                heightStyle: "content",
+                hide: null,
+                show: null,
+                // Callbacks
+                activate: null,
+                beforeActivate: null,
+                beforeLoad: null,
+                create: null,
+                load: null
+        }
+} );
+} );

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/core.js
@@ -0,0 +1,666 @@
+define( [
+        "qunit",
+        "jquery",
+        "./helper",
+        "ui/widgets/tabs"
+], function( QUnit, $, testHelper ) {
+var state = testHelper.state;
+QUnit.module( "tabs: core" );
+QUnit.test( "markup structure", function( assert ) {
+        assert.expect( 20 );
+        var element = $( "#tabs1" ).tabs(),
+                tabList = element.find( "ul, ol" ),
+                tabs = tabList.find( "li" ),
+                active = tabs.eq( 0 ),
+                anchors = tabs.find( "a" ),
+                panels = element.find( ".ui-tabs-panel" );
+        assert.hasClasses( element, "ui-tabs ui-widget ui-widget-content" );
+        assert.lacksClasses( element, "ui-tabs-collapsible" );
+        assert.hasClasses( tabList, "ui-tabs-nav ui-widget-header" );
+        assert.equal( tabList.length, 1, "The widget contains exactly one tab list" );
+        assert.hasClasses( tabs[ 0 ], "ui-tabs-tab" );
+        assert.hasClasses( tabs[ 1 ], "ui-tabs-tab" );
+        assert.hasClasses( tabs[ 2 ], "ui-tabs-tab" );
+        // DEPRECATED
+        assert.hasClasses( tabs[ 0 ], "ui-tab" );
+        assert.hasClasses( tabs[ 1 ], "ui-tab" );
+        assert.hasClasses( tabs[ 2 ], "ui-tab" );
+        assert.equal( tabs.length, 3, "There are exactly three tabs" );
+        assert.hasClasses( anchors[ 0 ], "ui-tabs-anchor" );
+        assert.hasClasses( anchors[ 1 ], "ui-tabs-anchor" );
+        assert.hasClasses( anchors[ 2 ], "ui-tabs-anchor" );
+        assert.equal( anchors.length, 3, "There are exactly 3 anchors" );
+        assert.hasClasses( active, "ui-tabs-active" );
+        assert.hasClasses( panels[ 0 ], "ui-tabs-panel ui-widget-content" );
+        assert.hasClasses( panels[ 1 ], "ui-tabs-panel ui-widget-content" );
+        assert.hasClasses( panels[ 2 ], "ui-tabs-panel ui-widget-content" );
+        assert.equal( panels.length, 3, "There are exactly 3 tab panels" );
+} );
+$.each( {
+        "deep ul": "#tabs3",
+        "multiple lists, ul first": "#tabs4",
+        "multiple lists, ol first": "#tabs5",
+        "empty list": "#tabs6"
+}, function( type, selector ) {
+        QUnit.test( "markup structure: " + type, function( assert ) {
+                assert.expect( 2 );
+                var element = $( selector ).tabs();
+                assert.hasClasses( element, "ui-tabs" );
+                assert.hasClasses( $( selector + "-list" ), "ui-tabs-nav" );
+        } );
+} );
+// #5893 - Sublist in the tab list are considered as tab
+QUnit.test( "nested list", function( assert ) {
+        assert.expect( 1 );
+        var element = $( "#tabs6" ).tabs();
+        assert.equal( element.tabs( "instance" ).anchors.length, 2, "should contain 2 tab" );
+} );
+QUnit.test( "disconnected from DOM", function( assert ) {
+        assert.expect( 2 );
+        var element = $( "#tabs1" ).remove().tabs();
+        assert.equal( element.find( ".ui-tabs-nav" ).length, 1, "should initialize nav" );
+        assert.equal( element.find( ".ui-tabs-panel" ).length, 3, "should initialize panels" );
+} );
+QUnit.test( "non-tab list items", function( assert ) {
+        assert.expect( 2 );
+        var element = $( "#tabs9" ).tabs();
+        assert.equal( element.tabs( "option", "active" ), 0, "defaults to first tab" );
+        assert.equal( element.find( ".ui-tabs-nav li.ui-state-active" ).index(), 1,
+                "first actual tab is active" );
+} );
+QUnit.test( "aria-controls", function( assert ) {
+        assert.expect( 7 );
+        var element = $( "#tabs1" ).tabs(),
+                tabs = element.find( ".ui-tabs-nav li" );
+        tabs.each( function() {
+                var tab = $( this ),
+                        anchor = tab.find( ".ui-tabs-anchor" );
+                assert.equal( anchor.prop( "hash" ).substring( 1 ), tab.attr( "aria-controls" ) );
+        } );
+        element = $( "#tabs2" ).tabs();
+        tabs = element.find( ".ui-tabs-nav li" );
+        assert.equal( tabs.eq( 0 ).attr( "aria-controls" ), "colon:test" );
+        assert.equal( tabs.eq( 1 ).attr( "aria-controls" ), "inline-style" );
+        assert.ok( /^ui-id-\d+$/.test( tabs.eq( 2 ).attr( "aria-controls" ) ), "generated id" );
+        assert.equal( tabs.eq( 3 ).attr( "aria-controls" ), "custom-id" );
+} );
+QUnit.test( "accessibility", function( assert ) {
+        assert.expect( 49 );
+        var element = $( "#tabs1" ).tabs( {
+                        active: 1,
+                        disabled: [ 2 ]
+                } ),
+                tabs = element.find( ".ui-tabs-nav li" ),
+                anchors = tabs.find( ".ui-tabs-anchor" ),
+                panels = element.find( ".ui-tabs-panel" );
+        assert.equal( element.find( ".ui-tabs-nav" ).attr( "role" ), "tablist", "tablist role" );
+        tabs.each( function( index ) {
+                var tab = tabs.eq( index ),
+                        anchor = anchors.eq( index ),
+                        anchorId = anchor.attr( "id" ),
+                        panel = panels.eq( index );
+                assert.equal( tab.attr( "role" ), "tab", "tab " + index + " role" );
+                assert.equal( tab.attr( "aria-labelledby" ), anchorId, "tab " + index + " aria-labelledby" );
+                assert.equal( anchor.attr( "role" ), "presentation", "anchor " + index + " role" );
+                assert.equal( anchor.attr( "tabindex" ), -1, "anchor " + index + " tabindex" );
+                assert.equal( panel.attr( "role" ), "tabpanel", "panel " + index + " role" );
+                assert.equal( panel.attr( "aria-labelledby" ), anchorId, "panel " + index + " aria-labelledby" );
+        } );
+        assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "active tab has aria-selected=true" );
+        assert.equal( tabs.eq( 1 ).attr( "tabindex" ), 0, "active tab has tabindex=0" );
+        assert.equal( tabs.eq( 1 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "active tab has aria-expanded=true" );
+        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "active panel has aria-hidden=false" );
+        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+        assert.equal( tabs.eq( 0 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+        assert.equal( tabs.eq( 0 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+        assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+        assert.equal( tabs.eq( 2 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+        assert.equal( tabs.eq( 2 ).attr( "aria-disabled" ), "true", "disabled tab has aria-disabled=true" );
+        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+        element.tabs( "option", "active", 0 );
+        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "active tab has aria-selected=true" );
+        assert.equal( tabs.eq( 0 ).attr( "tabindex" ), 0, "active tab has tabindex=0" );
+        assert.equal( tabs.eq( 0 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "active tab has aria-expanded=true" );
+        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "active panel has aria-hidden=false" );
+        assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+        assert.equal( tabs.eq( 1 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+        assert.equal( tabs.eq( 1 ).attr( "aria-disabled" ), null, "enabled tab does not have aria-disabled" );
+        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+        assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "inactive tab has aria-selected=false" );
+        assert.equal( tabs.eq( 2 ).attr( "tabindex" ), -1, "inactive tab has tabindex=-1" );
+        assert.equal( tabs.eq( 2 ).attr( "aria-disabled" ), "true", "disabled tab has aria-disabled=true" );
+        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "inactive tab has aria-expanded=false" );
+        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "inactive panel has aria-hidden=true" );
+} );
+QUnit.test( "accessibility - ajax", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 6 );
+        var element = $( "#tabs2" ).tabs(),
+                tab = element.find( ".ui-tabs-nav li" ).eq( 3 ),
+                panel = $( "#custom-id" );
+        assert.equal( panel.attr( "aria-live" ), "polite", "remote panel has aria-live" );
+        assert.equal( panel.attr( "aria-busy" ), null, "does not have aria-busy on init" );
+        element.tabs( "option", "active", 3 );
+        assert.hasClasses( tab, "ui-tabs-loading" );
+        assert.equal( panel.attr( "aria-busy" ), "true", "panel has aria-busy during load" );
+        element.one( "tabsload", function() {
+                setTimeout( function() {
+                        assert.equal( panel.attr( "aria-busy" ), null, "panel does not have aria-busy after load" );
+                        assert.lacksClasses( tab, "ui-tabs-loading" );
+                        ready();
+                }, 1 );
+        } );
+} );
+QUnit.test( "keyboard support - LEFT, RIGHT, UP, DOWN, HOME, END, SPACE, ENTER", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 92 );
+        var element = $( "#tabs1" ).tabs( {
+                        collapsible: true
+                } ),
+                tabs = element.find( ".ui-tabs-nav li" ),
+                panels = element.find( ".ui-tabs-panel" ),
+                keyCode = $.ui.keyCode;
+        element.tabs( "instance" ).delay = 1;
+        assert.equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
+        tabs.eq( 0 ).simulate( "focus" );
+        // Down, right, down (wrap), up (wrap)
+        function step1() {
+                assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "first tab has focus" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.DOWN } );
+                assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "DOWN moves focus to next tab" );
+                assert.lacksClasses( tabs.eq( 0 ), "ui-state-focus", "first tab is no longer focused" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+                assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                tabs.eq( 1 ).simulate( "keydown", { keyCode: keyCode.RIGHT } );
+                assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "RIGHT moves focus to next tab" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.DOWN } );
+                assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "DOWN wraps focus to first tab" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.UP } );
+                assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "UP wraps focus to last tab" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                setTimeout( step2, 25 );
+        }
+        // Left, home, space
+        function step2() {
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+                assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+                tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.LEFT } );
+                assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "LEFT moves focus to previous tab" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is still visible" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                tabs.eq( 1 ).simulate( "keydown", { keyCode: keyCode.HOME } );
+                assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "HOME moves focus to first tab" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+                assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is still hidden" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+                assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is still visible" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                // SPACE activates, cancels delay
+                tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.SPACE } );
+                setTimeout( step3 );
+        }
+        // End, enter
+        function step3() {
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tabs has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.END } );
+                assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "END moves focus to last tab" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tabs has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                // ENTER activates, cancels delay
+                tabs.eq( 0 ).simulate( "keydown", { keyCode: keyCode.ENTER } );
+                setTimeout( step4 );
+        }
+        // Enter (collapse)
+        function step4() {
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+                // ENTER collapses if active
+                tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.ENTER } );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                setTimeout( ready );
+        }
+        setTimeout( step1 );
+} );
+// Navigation with CTRL and COMMAND (both behave the same)
+$.each( {
+        ctrl: "CTRL",
+        meta: "COMMAND"
+}, function( modifier, label ) {
+        QUnit.test( "keyboard support - " + label + " navigation", function( assert ) {
+                var ready = assert.async();
+                assert.expect( 115 );
+                var element = $( "#tabs1" ).tabs(),
+                        tabs = element.find( ".ui-tabs-nav li" ),
+                        panels = element.find( ".ui-tabs-panel" ),
+                        keyCode = $.ui.keyCode;
+                element.tabs( "instance" ).delay = 1;
+                assert.equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
+                tabs.eq( 0 ).simulate( "focus" );
+                // Down
+                function step1() {
+                        var eventProperties = { keyCode: keyCode.DOWN };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "first tab has focus" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        tabs.eq( 0 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "DOWN moves focus to next tab" );
+                        assert.lacksClasses( tabs.eq( 0 ), ".ui-state-focus", "first tab is no longer focused" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step2, 25 );
+                }
+                // Right
+                function step2() {
+                        var eventProperties = { keyCode: keyCode.RIGHT };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                        tabs.eq( 1 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "RIGHT moves focus to next tab" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step3, 25 );
+                }
+                // Down (wrap)
+                function step3() {
+                        var eventProperties = { keyCode: keyCode.DOWN };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                        tabs.eq( 2 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "DOWN wraps focus to first tab" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step4, 25 );
+                }
+                // Up (wrap)
+                function step4() {
+                        var eventProperties = { keyCode: keyCode.UP };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        tabs.eq( 0 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "UP wraps focus to last tab" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step5, 25 );
+                }
+                // Left
+                function step5() {
+                        var eventProperties = { keyCode: keyCode.LEFT };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                        tabs.eq( 2 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "LEFT moves focus to previous tab" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step6, 25 );
+                }
+                // Home
+                function step6() {
+                        var eventProperties = { keyCode: keyCode.HOME };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                        tabs.eq( 1 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "HOME moves focus to first tab" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "false", "second tab has aria-selected=false" );
+                        assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is still hidden" );
+                        assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step7, 25 );
+                }
+                // End
+                function step7() {
+                        var eventProperties = { keyCode: keyCode.END };
+                        eventProperties[ modifier + "Key" ] = true;
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        tabs.eq( 0 ).simulate( "keydown", eventProperties );
+                        assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "END moves focus to last tab" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "false", "third tab has aria-selected=false" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is still hidden" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is still visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        setTimeout( step8, 25 );
+                }
+                // Space
+                function step8() {
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                        assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                        tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.SPACE } );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "false", "first tab has aria-selected=false" );
+                        assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+                        assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                        assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                        assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+                        assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+                        assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+                        setTimeout( ready );
+                }
+                setTimeout( step1 );
+        } );
+} );
+QUnit.test( "keyboard support - CTRL+UP, ALT+PAGE_DOWN, ALT+PAGE_UP", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 50 );
+        var element = $( "#tabs1" ).tabs(),
+                tabs = element.find( ".ui-tabs-nav li" ),
+                panels = element.find( ".ui-tabs-panel" ),
+                keyCode = $.ui.keyCode;
+        assert.equal( tabs.filter( ".ui-state-focus" ).length, 0, "no tabs focused on init" );
+        panels.attr( "tabindex", -1 );
+        panels.eq( 0 ).simulate( "focus" );
+        function step1() {
+                assert.strictEqual( document.activeElement, panels[ 0 ], "first panel is activeElement" );
+                panels.eq( 0 ).simulate( "keydown", { keyCode: keyCode.PAGE_DOWN, altKey: true } );
+                assert.strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
+                assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "ALT+PAGE_DOWN moves focus to next tab" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+                assert.ok( panels.eq( 1 ).is( ":visible" ), "second panel is visible" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "second tab has aria-expanded=true" );
+                assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "second panel has aria-hidden=false" );
+                assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+                tabs.eq( 1 ).simulate( "keydown", { keyCode: keyCode.PAGE_DOWN, altKey: true } );
+                assert.strictEqual( document.activeElement, tabs[ 2 ], "third tab is activeElement" );
+                assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "ALT+PAGE_DOWN moves focus to next tab" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                assert.ok( panels.eq( 1 ).is( ":hidden" ), "second panel is hidden" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "false", "second tab has aria-expanded=false" );
+                assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "true", "second panel has aria-hidden=true" );
+                tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.PAGE_DOWN, altKey: true } );
+                assert.strictEqual( document.activeElement, tabs[ 0 ], "first tab is activeElement" );
+                assert.hasClasses( tabs.eq( 0 ), "ui-state-focus", "ALT+PAGE_DOWN wraps focus to first tab" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-selected" ), "true", "first tab has aria-selected=true" );
+                assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel is visible" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "true", "first tab has aria-expanded=true" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "false", "first panel has aria-hidden=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                panels.eq( 0 ).simulate( "focus" );
+                setTimeout( step2 );
+        }
+        function step2() {
+                assert.strictEqual( document.activeElement, panels[ 0 ], "first panel is activeElement" );
+                panels.eq( 0 ).simulate( "keydown", { keyCode: keyCode.PAGE_UP, altKey: true } );
+                assert.strictEqual( document.activeElement, tabs[ 2 ], "third tab is activeElement" );
+                assert.hasClasses( tabs.eq( 2 ), "ui-state-focus", "ALT+PAGE_UP wraps focus to last tab" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-selected" ), "true", "third tab has aria-selected=true" );
+                assert.ok( panels.eq( 2 ).is( ":visible" ), "third panel is visible" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "true", "third tab has aria-expanded=true" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "false", "third panel has aria-hidden=false" );
+                assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel is hidden" );
+                assert.equal( tabs.eq( 0 ).attr( "aria-expanded" ), "false", "first tab has aria-expanded=false" );
+                assert.equal( panels.eq( 0 ).attr( "aria-hidden" ), "true", "first panel has aria-hidden=true" );
+                tabs.eq( 2 ).simulate( "keydown", { keyCode: keyCode.PAGE_UP, altKey: true } );
+                assert.strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
+                assert.hasClasses( tabs.eq( 1 ), "ui-state-focus", "ALT+PAGE_UP moves focus to previous tab" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-selected" ), "true", "second tab has aria-selected=true" );
+                assert.ok( panels.eq( 1 ).is( ":visible" ), "second panel is visible" );
+                assert.equal( tabs.eq( 1 ).attr( "aria-expanded" ), "true", "second tab has aria-expanded=true" );
+                assert.equal( panels.eq( 1 ).attr( "aria-hidden" ), "false", "second panel has aria-hidden=false" );
+                assert.ok( panels.eq( 2 ).is( ":hidden" ), "third panel is hidden" );
+                assert.equal( tabs.eq( 2 ).attr( "aria-expanded" ), "false", "third tab has aria-expanded=false" );
+                assert.equal( panels.eq( 2 ).attr( "aria-hidden" ), "true", "third panel has aria-hidden=true" );
+                panels.eq( 1 ).simulate( "focus" );
+                setTimeout( step3 );
+        }
+        function step3() {
+                assert.strictEqual( document.activeElement, panels[ 1 ], "second panel is activeElement" );
+                panels.eq( 1 ).simulate( "keydown", { keyCode: keyCode.UP, ctrlKey: true } );
+                assert.strictEqual( document.activeElement, tabs[ 1 ], "second tab is activeElement" );
+                setTimeout( ready );
+        }
+        setTimeout( step1 );
+} );
+QUnit.test( "#4033 - IE expands hash to full url and misinterprets tab as ajax", function( assert ) {
+        assert.expect( 2 );
+        var element = $( "<div><ul><li><a href='#tab'>Tab</a></li></ul><div id='tab'></div></div>" );
+        element.appendTo( "#qunit-fixture" );
+        element.tabs( {
+                beforeLoad: function() {
+                        event.preventDefault();
+                        assert.ok( false, "should not be an ajax tab" );
+                }
+        } );
+        assert.equal( element.find( ".ui-tabs-nav li" ).attr( "aria-controls" ), "tab", "aria-contorls attribute is correct" );
+        state( assert, element, 1 );
+} );
+} );

/inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/data/test.html
@@ -0,0 +1 @@
<p>…content loaded via Ajax.</p>

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/events.js
@@ -0,0 +1,327 @@
+define( [
+        "qunit",
+        "jquery",
+        "./helper",
+        "ui/widgets/tabs"
+], function( QUnit, $, testHelper ) {
+var state = testHelper.state;
+QUnit.module( "tabs: events" );
+QUnit.test( "create", function( assert ) {
+        assert.expect( 10 );
+        var element = $( "#tabs1" ),
+                tabs = element.find( "ul li" ),
+                panels = element.children( "div" );
+        element.tabs( {
+                create: function( event, ui ) {
+                        assert.equal( ui.tab.length, 1, "tab length" );
+                        assert.strictEqual( ui.tab[ 0 ], tabs[ 0 ], "tab" );
+                        assert.equal( ui.panel.length, 1, "panel length" );
+                        assert.strictEqual( ui.panel[ 0 ], panels[ 0 ], "panel" );
+                }
+        } );
+        element.tabs( "destroy" );
+        element.tabs( {
+                active: 2,
+                create: function( event, ui ) {
+                        assert.equal( ui.tab.length, 1, "tab length" );
+                        assert.strictEqual( ui.tab[ 0 ], tabs[ 2 ], "tab" );
+                        assert.equal( ui.panel.length, 1, "panel length" );
+                        assert.strictEqual( ui.panel[ 0 ], panels[ 2 ], "panel" );
+                }
+        } );
+        element.tabs( "destroy" );
+        element.tabs( {
+                active: false,
+                collapsible: true,
+                create: function( event, ui ) {
+                        assert.equal( ui.tab.length, 0, "tab length" );
+                        assert.equal( ui.panel.length, 0, "panel length" );
+                }
+        } );
+        element.tabs( "destroy" );
+} );
+QUnit.test( "beforeActivate", function( assert ) {
+        assert.expect( 38 );
+        var element = $( "#tabs1" ).tabs( {
+                        active: false,
+                        collapsible: true
+                } ),
+                tabs = element.find( ".ui-tabs-nav li" ),
+                anchors = tabs.find( ".ui-tabs-anchor" ),
+                panels = element.find( ".ui-tabs-panel" );
+        // From collapsed
+        element.one( "tabsbeforeactivate", function( event, ui ) {
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.oldTab.length, 0, "oldTab length" );
+                assert.equal( ui.oldPanel.length, 0, "oldPanel length" );
+                assert.equal( ui.newTab.length, 1, "newTab length" );
+                assert.strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
+                assert.equal( ui.newPanel.length, 1, "newPanel length" );
+                assert.strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
+                state( assert, element, 0, 0, 0 );
+        } );
+        element.tabs( "option", "active", 0 );
+        state( assert, element, 1, 0, 0 );
+        // Switching tabs
+        element.one( "tabsbeforeactivate", function( event, ui ) {
+                assert.equal( event.originalEvent.type, "click", "originalEvent" );
+                assert.equal( ui.oldTab.length, 1, "oldTab length" );
+                assert.strictEqual( ui.oldTab[ 0 ], tabs[ 0 ], "oldTab" );
+                assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+                assert.strictEqual( ui.oldPanel[ 0 ], panels[ 0 ], "oldPanel" );
+                assert.equal( ui.newTab.length, 1, "newTab length" );
+                assert.strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
+                assert.equal( ui.newPanel.length, 1, "newPanel length" );
+                assert.strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
+                state( assert, element, 1, 0, 0 );
+        } );
+        anchors.eq( 1 ).trigger( "click" );
+        state( assert, element, 0, 1, 0 );
+        // Collapsing
+        element.one( "tabsbeforeactivate", function( event, ui ) {
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.oldTab.length, 1, "oldTab length" );
+                assert.strictEqual( ui.oldTab[ 0 ], tabs[ 1 ], "oldTab" );
+                assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+                assert.strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
+                assert.equal( ui.newTab.length, 0, "newTab length" );
+                assert.equal( ui.newPanel.length, 0, "newPanel length" );
+                state( assert, element, 0, 1, 0 );
+        } );
+        element.tabs( "option", "active", false );
+        state( assert, element, 0, 0, 0 );
+        // Prevent activation
+        element.one( "tabsbeforeactivate", function( event, ui ) {
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.oldTab.length, 0, "oldTab length" );
+                assert.equal( ui.oldPanel.length, 0, "oldTab" );
+                assert.equal( ui.newTab.length, 1, "newTab length" );
+                assert.strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
+                assert.equal( ui.newPanel.length, 1, "newPanel length" );
+                assert.strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
+                event.preventDefault();
+                state( assert, element, 0, 0, 0 );
+        } );
+        element.tabs( "option", "active", 1 );
+        state( assert, element, 0, 0, 0 );
+} );
+QUnit.test( "activate", function( assert ) {
+        assert.expect( 30 );
+        var element = $( "#tabs1" ).tabs( {
+                        active: false,
+                        collapsible: true
+                } ),
+                tabs = element.find( ".ui-tabs-nav li" ),
+                anchors = element.find( ".ui-tabs-anchor" ),
+                panels = element.find( ".ui-tabs-panel" );
+        // From collapsed
+        element.one( "tabsactivate", function( event, ui ) {
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.oldTab.length, 0, "oldTab length" );
+                assert.equal( ui.oldPanel.length, 0, "oldPanel length" );
+                assert.equal( ui.newTab.length, 1, "newTab length" );
+                assert.strictEqual( ui.newTab[ 0 ], tabs[ 0 ], "newTab" );
+                assert.equal( ui.newPanel.length, 1, "newPanel length" );
+                assert.strictEqual( ui.newPanel[ 0 ], panels[ 0 ], "newPanel" );
+                state( assert, element, 1, 0, 0 );
+        } );
+        element.tabs( "option", "active", 0 );
+        state( assert, element, 1, 0, 0 );
+        // Switching tabs
+        element.one( "tabsactivate", function( event, ui ) {
+                assert.equal( event.originalEvent.type, "click", "originalEvent" );
+                assert.equal( ui.oldTab.length, 1, "oldTab length" );
+                assert.strictEqual( ui.oldTab[ 0 ], tabs[ 0 ], "oldTab" );
+                assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+                assert.strictEqual( ui.oldPanel[ 0 ], panels[ 0 ], "oldPanel" );
+                assert.equal( ui.newTab.length, 1, "newTab length" );
+                assert.strictEqual( ui.newTab[ 0 ], tabs[ 1 ], "newTab" );
+                assert.equal( ui.newPanel.length, 1, "newPanel length" );
+                assert.strictEqual( ui.newPanel[ 0 ], panels[ 1 ], "newPanel" );
+                state( assert, element, 0, 1, 0 );
+        } );
+        anchors.eq( 1 ).trigger( "click" );
+        state( assert, element, 0, 1, 0 );
+        // Collapsing
+        element.one( "tabsactivate", function( event, ui ) {
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.oldTab.length, 1, "oldTab length" );
+                assert.strictEqual( ui.oldTab[ 0 ], tabs[ 1 ], "oldTab" );
+                assert.equal( ui.oldPanel.length, 1, "oldPanel length" );
+                assert.strictEqual( ui.oldPanel[ 0 ], panels[ 1 ], "oldPanel" );
+                assert.equal( ui.newTab.length, 0, "newTab length" );
+                assert.equal( ui.newPanel.length, 0, "newPanel length" );
+                state( assert, element, 0, 0, 0 );
+        } );
+        element.tabs( "option", "active", false );
+        state( assert, element, 0, 0, 0 );
+        // Prevent activation
+        element.one( "tabsbeforeactivate", function( event ) {
+                assert.ok( true, "tabsbeforeactivate" );
+                event.preventDefault();
+        } );
+        element.one( "tabsactivate", function() {
+                assert.ok( false, "tabsactivate" );
+        } );
+        element.tabs( "option", "active", 1 );
+} );
+QUnit.test( "beforeLoad", function( assert ) {
+        assert.expect( 32 );
+        var tab, panelId, panel,
+                element = $( "#tabs2" );
+        // Init
+        element.one( "tabsbeforeload", function( event, ui ) {
+                tab = element.find( ".ui-tabs-nav li" ).eq( 2 );
+                panelId = tab.attr( "aria-controls" );
+                panel = $( "#" + panelId );
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.ok( "abort" in ui.jqXHR, "jqXHR" );
+                assert.ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
+                assert.equal( ui.tab.length, 1, "tab length" );
+                assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                assert.equal( ui.panel.length, 1, "panel length" );
+                assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                assert.equal( ui.panel.html(), "", "panel html" );
+                event.preventDefault();
+                state( assert, element, 0, 0, 1, 0, 0 );
+        } );
+        element.tabs( { active: 2 } );
+        state( assert, element, 0, 0, 1, 0, 0 );
+        assert.equal( panel.html(), "", "panel html after" );
+        element.tabs( "destroy" );
+        // .option()
+        element.one( "tabsbeforeload", function( event, ui ) {
+                tab = element.find( ".ui-tabs-nav li" ).eq( 2 );
+                panelId = tab.attr( "aria-controls" );
+                panel = $( "#" + panelId );
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.ok( "abort" in ui.jqXHR, "jqXHR" );
+                assert.ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
+                assert.equal( ui.tab.length, 1, "tab length" );
+                assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                assert.equal( ui.panel.length, 1, "panel length" );
+                assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                assert.equal( ui.panel.html(), "", "panel html" );
+                event.preventDefault();
+                state( assert, element, 1, 0, 0, 0, 0 );
+        } );
+        element.tabs();
+        element.tabs( "option", "active", 2 );
+        state( assert, element, 0, 0, 1, 0, 0 );
+        assert.equal( panel.html(), "", "panel html after" );
+        // Click, change panel content
+        element.one( "tabsbeforeload", function( event, ui ) {
+                tab = element.find( ".ui-tabs-nav li" ).eq( 3 );
+                panelId = tab.attr( "aria-controls" );
+                panel = $( "#" + panelId );
+                assert.equal( event.originalEvent.type, "click", "originalEvent" );
+                assert.ok( "abort" in ui.jqXHR, "jqXHR" );
+                assert.ok( ui.ajaxSettings.url, "data/test.html", "ajaxSettings.url" );
+                assert.equal( ui.tab.length, 1, "tab length" );
+                assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                assert.equal( ui.panel.length, 1, "panel length" );
+                assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                ui.panel.html( "<p>testing</p>" );
+                event.preventDefault();
+                state( assert, element, 0, 0, 1, 0, 0 );
+        } );
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 3 ).trigger( "click" );
+        state( assert, element, 0, 0, 0, 1, 0 );
+        // .toLowerCase() is needed to convert <P> to <p> in old IEs
+        assert.equal( panel.html().toLowerCase(), "<p>testing</p>", "panel html after" );
+} );
+QUnit.test( "load", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 21 );
+        var tab, panelId, panel,
+                element = $( "#tabs2" );
+        // Init
+        element.one( "tabsload", function( event, ui ) {
+                tab = element.find( ".ui-tabs-nav li" ).eq( 2 );
+                panelId = tab.attr( "aria-controls" );
+                panel = $( "#" + panelId );
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.tab.length, 1, "tab length" );
+                assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                assert.equal( ui.panel.length, 1, "panel length" );
+                assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                assert.equal( ui.panel.find( "p" ).length, 1, "panel html" );
+                state( assert, element, 0, 0, 1, 0, 0 );
+                tabsload1();
+        } );
+        element.tabs( { active: 2 } );
+        function tabsload1() {
+                // .option()
+                element.one( "tabsload", function( event, ui ) {
+                        tab = element.find( ".ui-tabs-nav li" ).eq( 3 );
+                        panelId = tab.attr( "aria-controls" );
+                        panel = $( "#" + panelId );
+                        assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                        assert.equal( ui.tab.length, 1, "tab length" );
+                        assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                        assert.equal( ui.panel.length, 1, "panel length" );
+                        assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                        assert.equal( ui.panel.find( "p" ).length, 1, "panel html" );
+                        state( assert, element, 0, 0, 0, 1, 0 );
+                        tabsload2();
+                } );
+                element.tabs( "option", "active", 3 );
+        }
+        function tabsload2() {
+                // Click, change panel content
+                element.one( "tabsload", function( event, ui ) {
+                        tab = element.find( ".ui-tabs-nav li" ).eq( 4 );
+                        panelId = tab.attr( "aria-controls" );
+                        panel = $( "#" + panelId );
+                        assert.equal( event.originalEvent.type, "click", "originalEvent" );
+                        assert.equal( ui.tab.length, 1, "tab length" );
+                        assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                        assert.equal( ui.panel.length, 1, "panel length" );
+                        assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                        assert.equal( ui.panel.find( "p" ).length, 1, "panel html" );
+                        state( assert, element, 0, 0, 0, 0, 1 );
+                        ready();
+                } );
+                element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 4 ).trigger( "click" );
+        }
+} );
+} );

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/helper.js
@@ -0,0 +1,78 @@
+define( [
+        "jquery",
+        "lib/helper",
+        "ui/widgets/tabs"
+], function( $, helper ) {
+return $.extend( helper, {
+        disabled: function( assert, tabs, state ) {
+                var expected, actual,
+                        internalState = tabs.tabs( "option", "disabled" );
+                if ( internalState === false ) {
+                        internalState = [];
+                }
+                if ( internalState === true ) {
+                        internalState = $.map( new Array( tabs.find( ".ui-tabs-nav li" ).length ), function( _, index ) {
+                                return index;
+                        } );
+                }
+                expected = $.map( new Array( tabs.find( ".ui-tabs-nav li" ).length ), function( _, index ) {
+                        if ( typeof state === "boolean" ) {
+                                return state ? 1 : 0;
+                        } else {
+                                return $.inArray( index, state ) !== -1 ? 1 : 0;
+                        }
+                } );
+                actual = tabs.find( ".ui-tabs-nav li" ).map( function( index ) {
+                        var tab = $( this ),
+                                tabIsDisabled = tab.hasClass( "ui-state-disabled" );
+                        if ( tabIsDisabled && $.inArray( index, internalState ) !== -1 ) {
+                                return 1;
+                        }
+                        if ( !tabIsDisabled && $.inArray( index, internalState ) === -1 ) {
+                                return 0;
+                        }
+                        // Mixed state - invalid
+                        return -1;
+                } ).get();
+                assert.deepEqual( tabs.tabs( "option", "disabled" ), state );
+                assert.deepEqual( actual, expected );
+        },
+        equalHeight: function( assert, tabs, height ) {
+                tabs.find( ".ui-tabs-panel" ).each( function() {
+                        // Handle overly-precise values
+                        var actualHeight = parseFloat( $( this ).outerHeight().toFixed( 1 ) );
+                        assert.equal( actualHeight, height );
+                } );
+        },
+        state: function( assert, tabs ) {
+                var expected = $.makeArray( arguments ).slice( 2 ),
+                        actual = tabs.find( ".ui-tabs-nav li" ).map( function() {
+                                var tab = $( this ),
+                                        panel = $( $.ui.tabs.prototype._sanitizeSelector(
+                                                "#" + tab.attr( "aria-controls" ) ) ),
+                                        tabIsActive = tab.hasClass( "ui-state-active" ),
+                                        panelIsActive = panel.css( "display" ) !== "none";
+                                if ( tabIsActive && panelIsActive ) {
+                                        return 1;
+                                }
+                                if ( !tabIsActive && !panelIsActive ) {
+                                        return 0;
+                                }
+                                return -1; // Mixed state - invalid
+                        } ).get();
+                assert.deepEqual( actual, expected );
+        }
+} );
+} );

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/methods.js
@@ -0,0 +1,305 @@
+define( [
+        "qunit",
+        "jquery",
+        "./helper",
+        "ui/widgets/tabs"
+], function( QUnit, $, testHelper ) {
+var disabled = testHelper.disabled,
+        state = testHelper.state;
+QUnit.module( "tabs: methods" );
+QUnit.test( "destroy", function( assert ) {
+        assert.expect( 2 );
+        assert.domEqual( "#tabs1", function() {
+                $( "#tabs1" ).tabs().tabs( "destroy" );
+        } );
+        assert.domEqual( "#tabs2", function() {
+                $( "#tabs2" ).tabs().tabs( "destroy" );
+        } );
+} );
+QUnit.test( "destroy - ajax", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 1 );
+        assert.domEqual( "#tabs2", function( done ) {
+                var element = $( "#tabs2" ).tabs( {
+                        load: function() {
+                                setTimeout( function() {
+                                        element.tabs( "destroy" );
+                                        done();
+                                        ready();
+                                } );
+                        }
+                } );
+                element.tabs( "option", "active", 2 );
+        } );
+} );
+QUnit.test( "enable", function( assert ) {
+        assert.expect( 8 );
+        var element = $( "#tabs1" ).tabs( { disabled: true } );
+        disabled( assert, element, true );
+        element.tabs( "enable" );
+        disabled( assert, element, false );
+        element.tabs( "destroy" );
+        element.tabs( { disabled: [ 0, 1 ] } );
+        disabled( assert, element, [ 0, 1 ] );
+        element.tabs( "enable" );
+        disabled( assert, element, false );
+} );
+QUnit.test( "enable( index )", function( assert ) {
+        assert.expect( 10 );
+        var element = $( "#tabs1" ).tabs( { disabled: true } );
+        disabled( assert, element, true );
+        // fully disabled -> partially disabled
+        element.tabs( "enable", 1 );
+        disabled( assert, element, [ 0, 2 ] );
+        // partially disabled -> partially disabled
+        element.tabs( "enable", 2 );
+        disabled( assert, element, [ 0 ] );
+        // already enabled tab, no change
+        element.tabs( "enable", 2 );
+        disabled( assert, element, [ 0 ] );
+        // partially disabled -> fully enabled
+        element.tabs( "enable", 0 );
+        disabled( assert, element, false );
+} );
+QUnit.test( "disable", function( assert ) {
+        assert.expect( 8 );
+        var element = $( "#tabs1" ).tabs( { disabled: false } );
+        disabled( assert, element, false );
+        element.tabs( "disable" );
+        disabled( assert, element, true );
+        element.tabs( "destroy" );
+        element.tabs( { disabled: [ 0, 1 ] } );
+        disabled( assert, element, [ 0, 1 ] );
+        element.tabs( "disable" );
+        disabled( assert, element, true );
+} );
+QUnit.test( "disable( index )", function( assert ) {
+        assert.expect( 10 );
+        var element = $( "#tabs1" ).tabs( { disabled: false } );
+        disabled( assert, element, false );
+        // fully enabled -> partially disabled
+        element.tabs( "disable", 1 );
+        disabled( assert, element, [ 1 ] );
+        // partially disabled -> partially disabled
+        element.tabs( "disable", 2 );
+        disabled( assert, element, [ 1, 2 ] );
+        // already disabled tab, no change
+        element.tabs( "disable", 2 );
+        disabled( assert, element, [ 1, 2 ] );
+        // partially disabled -> fully disabled
+        element.tabs( "disable", 0 );
+        disabled( assert, element, true );
+} );
+QUnit.test( "refresh", function( assert ) {
+        assert.expect( 27 );
+        var element = $( "#tabs1" ).tabs();
+        state( assert, element, 1, 0, 0 );
+        disabled( assert, element, false );
+        // Disable tab via markup
+        element.find( ".ui-tabs-nav li" ).eq( 1 ).addClass( "ui-state-disabled" );
+        element.tabs( "refresh" );
+        state( assert, element, 1, 0, 0 );
+        disabled( assert, element, [ 1 ] );
+        // Add remote tab
+        element.find( ".ui-tabs-nav" ).append( "<li id='newTab'><a href='data/test.html'>new</a></li>" );
+        element.tabs( "refresh" );
+        state( assert, element, 1, 0, 0, 0 );
+        disabled( assert, element, [ 1 ] );
+        assert.equal( element.find( "#" + $( "#newTab" ).attr( "aria-controls" ) ).length, 1,
+                "panel added for remote tab" );
+        // Remove all tabs
+        element.find( ".ui-tabs-nav li, .ui-tabs-panel" ).remove();
+        element.tabs( "refresh" );
+        state( assert, element );
+        assert.equal( element.tabs( "option", "active" ), false, "no active tab" );
+        // Add tabs
+        element.find( ".ui-tabs-nav" )
+                .append( "<li class='ui-state-disabled'><a href='#newTab2'>new 2</a></li>" )
+                .append( "<li><a href='#newTab3'>new 3</a></li>" )
+                .append( "<li><a href='#newTab4'>new 4</a></li>" )
+                .append( "<li><a href='#newTab5'>new 5</a></li>" );
+        element
+                .append( "<div id='newTab2'>new 2</div>" )
+                .append( "<div id='newTab3'>new 3</div>" )
+                .append( "<div id='newTab4'>new 4</div>" )
+                .append( "<div id='newTab5'>new 5</div>" );
+        element.tabs( "refresh" );
+        state( assert, element, 0, 0, 0, 0 );
+        disabled( assert, element, [ 0 ] );
+        // Activate third tab
+        element.tabs( "option", "active", 2 );
+        state( assert, element, 0, 0, 1, 0 );
+        disabled( assert, element, [ 0 ] );
+        // Remove fourth tab, third tab should stay active
+        element.find( ".ui-tabs-nav li" ).eq( 3 ).remove();
+        element.find( ".ui-tabs-panel" ).eq( 3 ).remove();
+        element.tabs( "refresh" );
+        state( assert, element, 0, 0, 1 );
+        disabled( assert, element, [ 0 ] );
+        // Remove third (active) tab, second tab should become active
+        element.find( ".ui-tabs-nav li" ).eq( 2 ).remove();
+        element.find( ".ui-tabs-panel" ).eq( 2 ).remove();
+        element.tabs( "refresh" );
+        state( assert, element, 0, 1 );
+        disabled( assert, element, [ 0 ] );
+        // Remove first tab, previously active tab (now first) should stay active
+        element.find( ".ui-tabs-nav li" ).eq( 0 ).remove();
+        element.find( ".ui-tabs-panel" ).eq( 0 ).remove();
+        element.tabs( "refresh" );
+        state( assert, element, 1 );
+        disabled( assert, element, false );
+} );
+QUnit.test( "refresh - looping", function( assert ) {
+        assert.expect( 6 );
+        var element = $( "#tabs1" ).tabs( {
+                disabled: [ 0 ],
+                active: 1
+        } );
+        state( assert, element, 0, 1, 0 );
+        disabled( assert, element, [ 0 ] );
+        // Remove active, jump to previous
+        // previous is disabled, just back one more
+        // reached first tab, move to end
+        // activate last tab
+        element.find( ".ui-tabs-nav li" ).eq( 2 ).remove();
+        element.tabs( "refresh" );
+        state( assert, element, 0, 1 );
+        disabled( assert, element, [ 0 ] );
+} );
+QUnit.test( "load", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 30 );
+        var element = $( "#tabs2" ).tabs();
+        // Load content of inactive tab
+        // useful for preloading content with custom caching
+        element.one( "tabsbeforeload", function( event, ui ) {
+                var tab = element.find( ".ui-tabs-nav li" ).eq( 3 ),
+                        panelId = tab.attr( "aria-controls" ),
+                        panel = $( "#" + panelId );
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( ui.tab.length, 1, "tab length" );
+                assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                assert.equal( ui.panel.length, 1, "panel length" );
+                assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                state( assert, element, 1, 0, 0, 0, 0 );
+        } );
+        element.one( "tabsload", function( event, ui ) {
+                // TODO: remove wrapping in 2.0
+                var uiTab = $( ui.tab ),
+                        uiPanel = $( ui.panel ),
+                        tab = element.find( ".ui-tabs-nav li" ).eq( 3 ),
+                        panelId = tab.attr( "aria-controls" ),
+                        panel = $( "#" + panelId );
+                assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                assert.equal( uiTab.length, 1, "tab length" );
+                assert.strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
+                assert.equal( uiPanel.length, 1, "panel length" );
+                assert.strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
+                assert.equal( uiPanel.find( "p" ).length, 1, "panel html" );
+                state( assert, element, 1, 0, 0, 0, 0 );
+                setTimeout( tabsload1 );
+        } );
+        element.tabs( "load", 3 );
+        state( assert, element, 1, 0, 0, 0, 0 );
+        function tabsload1() {
+                // no need to test details of event (tested in events tests)
+                element.one( "tabsbeforeload", function() {
+                        assert.ok( true, "tabsbeforeload invoked" );
+                } );
+                element.one( "tabsload", function() {
+                        assert.ok( true, "tabsload invoked" );
+                        setTimeout( tabsload2 );
+                } );
+                element.tabs( "option", "active", 3 );
+                state( assert, element, 0, 0, 0, 1, 0 );
+        }
+        function tabsload2() {
+                // reload content of active tab
+                element.one( "tabsbeforeload", function( event, ui ) {
+                        var tab = element.find( ".ui-tabs-nav li" ).eq( 3 ),
+                                panelId = tab.attr( "aria-controls" ),
+                                panel = $( "#" + panelId );
+                        assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                        assert.equal( ui.tab.length, 1, "tab length" );
+                        assert.strictEqual( ui.tab[ 0 ], tab[ 0 ], "tab" );
+                        assert.equal( ui.panel.length, 1, "panel length" );
+                        assert.strictEqual( ui.panel[ 0 ], panel[ 0 ], "panel" );
+                        state( assert, element, 0, 0, 0, 1, 0 );
+                } );
+                element.one( "tabsload", function( event, ui ) {
+                        // TODO: remove wrapping in 2.0
+                        var uiTab = $( ui.tab ),
+                                uiPanel = $( ui.panel ),
+                                tab = element.find( ".ui-tabs-nav li" ).eq( 3 ),
+                                panelId = tab.attr( "aria-controls" ),
+                                panel = $( "#" + panelId );
+                        assert.ok( !( "originalEvent" in event ), "originalEvent" );
+                        assert.equal( uiTab.length, 1, "tab length" );
+                        assert.strictEqual( uiTab[ 0 ], tab[ 0 ], "tab" );
+                        assert.equal( uiPanel.length, 1, "panel length" );
+                        assert.strictEqual( uiPanel[ 0 ], panel[ 0 ], "panel" );
+                        state( assert, element, 0, 0, 0, 1, 0 );
+                        ready();
+                } );
+                element.tabs( "load", 3 );
+                state( assert, element, 0, 0, 0, 1, 0 );
+        }
+} );
+QUnit.test( "widget", function( assert ) {
+        assert.expect( 2 );
+        var element = $( "#tabs1" ).tabs(),
+                widgetElement = element.tabs( "widget" );
+        assert.equal( widgetElement.length, 1, "one element" );
+        assert.strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" );
+} );
+} );

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/options.js
@@ -0,0 +1,376 @@
+define( [
+        "qunit",
+        "jquery",
+        "./helper",
+        "ui/widgets/tabs"
+], function( QUnit, $, testHelper ) {
+var disabled = testHelper.disabled,
+        equalHeight = testHelper.equalHeight,
+        state = testHelper.state;
+QUnit.module( "tabs: options" );
+QUnit.test( "{ active: default }", function( assert ) {
+        assert.expect( 6 );
+        var element = $( "#tabs1" ).tabs();
+        assert.equal( element.tabs( "option", "active" ), 0, "should be 0 by default" );
+        state( assert, element, 1, 0, 0 );
+        element.tabs( "destroy" );
+        location.hash = "#fragment-3";
+        element = $( "#tabs1" ).tabs();
+        assert.equal( element.tabs( "option", "active" ), 2, "should be 2 based on URL" );
+        state( assert, element, 0, 0, 1 );
+        element.tabs( "destroy" );
+        location.hash = "#custom-id";
+        element = $( "#tabs2" ).tabs();
+        assert.equal( element.tabs( "option", "active" ), 3, "should be 3 based on URL" );
+        state( assert, element, 0, 0, 0, 1, 0 );
+        element.tabs( "destroy" );
+        location.hash = "#";
+} );
+QUnit.test( "{ active: false }", function( assert ) {
+        assert.expect( 7 );
+        var element = $( "#tabs1" ).tabs( {
+                active: false,
+                collapsible: true
+        } );
+        state( assert, element, 0, 0, 0 );
+        assert.equal( element.find( ".ui-tabs-nav .ui-state-active" ).length, 0, "no tabs selected" );
+        assert.strictEqual( element.tabs( "option", "active" ), false );
+        element.tabs( "option", "collapsible", false );
+        state( assert, element, 1, 0, 0 );
+        assert.equal( element.tabs( "option", "active" ), 0 );
+        element.tabs( "destroy" );
+        element.tabs( {
+                active: false
+        } );
+        state( assert, element, 1, 0, 0 );
+        assert.strictEqual( element.tabs( "option", "active" ), 0 );
+} );
+QUnit.test( "{ active: Number }", function( assert ) {
+        assert.expect( 8 );
+        var element = $( "#tabs1" ).tabs( {
+                active: 2
+        } );
+        assert.equal( element.tabs( "option", "active" ), 2 );
+        state( assert, element, 0, 0, 1 );
+        element.tabs( "option", "active", 0 );
+        assert.equal( element.tabs( "option", "active" ), 0 );
+        state( assert, element, 1, 0, 0 );
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "click" );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        element.tabs( "option", "active", 10 );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+} );
+QUnit.test( "{ active: -Number }", function( assert ) {
+        assert.expect( 8 );
+        var element = $( "#tabs1" ).tabs( {
+                active: -1
+        } );
+        assert.equal( element.tabs( "option", "active" ), 2 );
+        state( assert, element, 0, 0, 1 );
+        element.tabs( "option", "active", -2 );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        element.tabs( "option", "active", -10 );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        element.tabs( "option", "active", -3 );
+        assert.equal( element.tabs( "option", "active" ), 0 );
+        state( assert, element, 1, 0, 0 );
+} );
+QUnit.test( "active - mismatched tab/panel order", function( assert ) {
+        assert.expect( 3 );
+        location.hash = "#tabs7-2";
+        var element = $( "#tabs7" ).tabs();
+        assert.equal( element.tabs( "option", "active" ), 1, "should be 1 based on URL" );
+        state( assert, element, 0, 1 );
+        element.tabs( "option", "active", 0 );
+        state( assert, element, 1, 0 );
+        location.hash = "#";
+} );
+QUnit.test( "collapsible", function( assert ) {
+        assert.expect( 13 );
+        var element = $( "#tabs1" ).tabs( {
+                active: 1,
+                collapsible: true
+        } );
+        assert.hasClasses( element, "ui-tabs-collapsible" );
+        element.tabs( "option", "active", false );
+        assert.equal( element.tabs( "option", "active" ), false );
+        state( assert, element, 0, 0, 0 );
+        element.tabs( "option", "active", 1 );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        element.find( ".ui-state-active .ui-tabs-anchor" ).trigger( "click" );
+        assert.equal( element.tabs( "option", "active" ), false );
+        state( assert, element, 0, 0, 0 );
+        element.tabs( "option", "collapsible", false );
+        assert.lacksClasses( element, "ui-tabs-collapsible" );
+        element.tabs( "option", "collapsible", true );
+        assert.hasClasses( element, "ui-tabs-collapsible" );
+        element.tabs( {
+                active: 1,
+                collapsible: false
+        } );
+        element.tabs( "option", "active", false );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        element.find( ".ui-state-active .ui-tabs-anchor" ).eq( 1 ).trigger( "click" );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+} );
+QUnit.test( "disabled", function( assert ) {
+        assert.expect( 23 );
+        // Fully enabled by default
+        var event,
+                element = $( "#tabs1" ).tabs();
+        disabled( assert, element, false );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
+        assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+        // Disable single tab
+        element.tabs( "option", "disabled", [ 1 ] );
+        disabled( assert, element, [ 1 ] );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
+        assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+        // Disabled active tab
+        element.tabs( "option", "disabled", [ 0, 1 ] );
+        disabled( assert, element, [ 0, 1 ] );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
+        assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+        // Disable all tabs
+        element.tabs( "option", "disabled", [ 0, 1, 2 ] );
+        disabled( assert, element, true );
+        assert.lacksClasses( element.tabs( "widget" ), "ui-state-disabled" );
+        assert.hasClasses( element.tabs( "widget" ), "ui-tabs-disabled" );
+        assert.ok( !element.tabs( "widget" ).attr( "aria-disabled" ), "after: wrapper doesn't have aria-disabled attr" );
+        event = $.Event( "click" );
+        element.find( ".ui-tabs-anchor" ).eq( 0 ).trigger( event );
+        assert.ok( event.isDefaultPrevented(), "click is prevented for disabled tab" );
+        // Enable all tabs
+        element.tabs( "option", "disabled", [] );
+        disabled( assert, element, false );
+} );
+QUnit.test( "{ event: null }", function( assert ) {
+        assert.expect( 5 );
+        var element = $( "#tabs1" ).tabs( {
+                event: null
+        } );
+        state( assert, element, 1, 0, 0 );
+        element.tabs( "option", "active", 1 );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        // Ensure default click handler isn't bound
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 2 ).trigger( "click" );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+} );
+QUnit.test( "{ event: custom }", function( assert ) {
+        assert.expect( 11 );
+        var element = $( "#tabs1" ).tabs( {
+                event: "custom1 custom2"
+        } );
+        state( assert, element, 1, 0, 0 );
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "custom1" );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        // Ensure default click handler isn't bound
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 2 ).trigger( "click" );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 2 ).trigger( "custom2" );
+        assert.equal( element.tabs( "option", "active" ), 2 );
+        state( assert, element, 0, 0, 1 );
+        element.tabs( "option", "event", "custom3" );
+        // Ensure old event handlers are unbound
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "custom1" );
+        assert.equal( element.tabs( "option", "active" ), 2 );
+        state( assert, element, 0, 0, 1 );
+        element.find( ".ui-tabs-nav .ui-tabs-anchor" ).eq( 1 ).trigger( "custom3" );
+        assert.equal( element.tabs( "option", "active" ), 1 );
+        state( assert, element, 0, 1, 0 );
+} );
+QUnit.test( "{ heightStyle: 'auto' }", function( assert ) {
+        assert.expect( 2 );
+        var element = $( "#tabs8" ).tabs( { heightStyle: "auto" } );
+        equalHeight( assert, element, 45 );
+} );
+QUnit.test( "{ heightStyle: 'content' }", function( assert ) {
+        assert.expect( 2 );
+        var element = $( "#tabs8" ).tabs( { heightStyle: "content" } ),
+                sizes = element.find( ".ui-tabs-panel" ).map( function() {
+                        return $( this ).height();
+                } ).get();
+        assert.equal( sizes[ 0 ], 45 );
+        assert.equal( sizes[ 1 ], 15 );
+} );
+QUnit.test( "{ heightStyle: 'fill' }", function( assert ) {
+        assert.expect( 4 );
+        $( "#tabs8Wrapper" ).height( 500 );
+        var element = $( "#tabs8" ).tabs( { heightStyle: "fill" } );
+        equalHeight( assert, element, 485 );
+        element.tabs( "destroy" );
+        element = $( "#tabs8" ).css( {
+                "border": "1px solid black",
+                "padding": "1px 0"
+        } );
+        element.tabs( { heightStyle: "fill" } );
+        equalHeight( assert, element, 481 );
+} );
+QUnit.test( "{ heightStyle: 'fill' } with sibling", function( assert ) {
+        assert.expect( 2 );
+        $( "#tabs8Wrapper" ).height( 500 );
+        $( "<p>Lorem Ipsum</p>" )
+                .css( {
+                        height: 50,
+                        marginTop: 20,
+                        marginBottom: 30
+                } )
+                .prependTo( "#tabs8Wrapper" );
+        var element = $( "#tabs8" ).tabs( { heightStyle: "fill" } );
+        equalHeight( assert, element, 385 );
+} );
+QUnit.test( "{ heightStyle: 'fill' } with multiple siblings", function( assert ) {
+        assert.expect( 2 );
+        $( "#tabs8Wrapper" ).height( 500 );
+        $( "<p>Lorem Ipsum</p>" )
+                .css( {
+                        height: 50,
+                        marginTop: 20,
+                        marginBottom: 30
+                } )
+                .prependTo( "#tabs8Wrapper" );
+        $( "<p>Lorem Ipsum</p>" )
+                .css( {
+                        height: 50,
+                        marginTop: 20,
+                        marginBottom: 30,
+                        position: "absolute"
+                } )
+                .prependTo( "#tabs8Wrapper" );
+        $( "<p>Lorem Ipsum</p>" )
+                .css( {
+                        height: 25,
+                        marginTop: 10,
+                        marginBottom: 15
+                } )
+                .prependTo( "#tabs8Wrapper" );
+        var element = $( "#tabs8" ).tabs( { heightStyle: "fill" } );
+        equalHeight( assert, element, 335 );
+} );
+QUnit.test( "hide and show: false", function( assert ) {
+        assert.expect( 3 );
+        var element = $( "#tabs1" ).tabs( {
+                        show: false,
+                        hide: false
+                } ),
+                widget = element.tabs( "instance" ),
+                panels = element.find( ".ui-tabs-panel" );
+        widget._show = function() {
+                assert.ok( false, "_show() called" );
+        };
+        widget._hide = function() {
+                assert.ok( false, "_hide() called" );
+        };
+        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel visible" );
+        element.tabs( "option", "active", 1 );
+        assert.ok( panels.eq( 0 ).is( ":hidden" ), "first panel hidden" );
+        assert.ok( panels.eq( 1 ).is( ":visible" ), "second panel visible" );
+} );
+QUnit.test( "hide and show - animation", function( assert ) {
+        var ready = assert.async();
+        assert.expect( 5 );
+        var element = $( "#tabs1" ).tabs( {
+                        show: "drop",
+                        hide: 2000
+                } ),
+                widget = element.tabs( "instance" ),
+                panels = element.find( ".ui-tabs-panel" );
+        widget._show = function( element, options, callback ) {
+                assert.strictEqual( element[ 0 ], panels[ 1 ], "correct element in _show()" );
+                assert.equal( options, "drop", "correct options in _show()" );
+                setTimeout( function() {
+                        callback();
+                } );
+        };
+        widget._hide = function( element, options, callback ) {
+                assert.strictEqual( element[ 0 ], panels[ 0 ], "correct element in _hide()" );
+                assert.equal( options, 2000, "correct options in _hide()" );
+                setTimeout( function() {
+                        callback();
+                        ready();
+                } );
+        };
+        assert.ok( panels.eq( 0 ).is( ":visible" ), "first panel visible" );
+        element.tabs( "option", "active", 1 );
+} );
+} );

 /inventoryBrowser/node_modules/jquery-ui/tests/unit/tabs/tabs.html
@@ -0,0 +1,130 @@
+<!doctype html>
+<html lang="en">
+<head>
+        <meta charset="utf-8">
+        <title>jQuery UI Tabs Test Suite</title>
+        <script src="../../../external/requirejs/require.js"></script>
+        <script src="../../lib/css.js" data-modules="core tabs"></script>
+        <script src="../../lib/bootstrap.js" data-widget="tabs"></script>
+        <style>
+        #tabs8, #tabs8 * {
+                margin: 0;
+                padding: 0;
+                font-size: 12px;
+                line-height: 15px;
+        }
+        </style>
+</head>
+<body>
+<div id="qunit"></div>
+<div id="qunit-fixture">
+<div id="tabs1">
+        <ul>
+                <li><a href="#fragment-1"><span>1</span></a></li>
+                <li><a href="#fragment-2"><span>2</span></a></li>
+                <li><a href="#fragment-3"><span>3</span></a></li>
+        </ul>
+        <div id="fragment-1"></div>
+        <div id="fragment-2"></div>
+        <div id="fragment-3"></div>
+</div>
+<div id="tabs2">
+        <ul>
+                <li><a href="#colon:test"><span>1</span></a></li>
+                <li><a href="#inline-style"><span>2</span></a></li>
+                <li><a href="data/test.html#test"><span>3</span></a></li>
+                <li aria-controls="custom-id"><a href="data/test.html"><span>4</span></a></li>
+                <li><a href="data/test.html" title="∫ßáö Սե"><span>5</span></a></li>
+        </ul>
+        <div id="colon:test"></div>
+        <div style="height: 300px;" id="inline-style"></div>
+        <div id="custom-id"></div>
+</div>
+<div id="tabs3">
+        <div>
+                <ul id="tabs3-list">
+                        <li><a href="#tabs3-1">1</a></li>
+                </ul>
+        </div>
+</div>
+<div id="tabs4">
+        <ul id="tabs4-list">
+                <li><a href="#tabs4-1">1</a></li>
+        </ul>
+        <ol>
+                <li><a href="#tabs4-1">1</a></li>
+        </ol>
+</div>
+<div id="tabs4a">
+        <ol id="tabs4a-list">
+                <li><a href="#tabs4a-1">1</a></li>
+        </ol>
+        <ul>
+                <li><a href="#tabs4a-1">1</a></li>
+        </ul>
+</div>
+<div id="tabs5">
+        <div>
+                <ul id="tabs5-list"></ul>
+        </div>
+</div>
+<div id="tabs6">
+        <ul id="tabs6-list">
+                <li><a href="#tabs6-1">1</a>
+                        <ul>
+                                <li><a href="#item6-3">3</a></li>
+                                <li><a href="#item6-4">4</a></li>
+                        </ul>
+                </li>
+                <li><a href="#tabs6-2">2</a></li>
+        </ul>
+        <div id="tabs6-1"></div>
+        <div id="tabs6-2"></div>
+</div>
+<div id="tabs7">
+        <ul id="tabs7-list">
+                <li><a href="#tabs7-1">1</a></li>
+                <li><a href="#tabs7-2">2</a></li>
+        </ul>
+        <div id="tabs7-2"></div>
+        <div id="tabs7-1"></div>
+</div>
+<div id="tabs8Wrapper">
+        <div id="tabs8">
+                <ul id="tabs8-list">
+                        <li><a href="#tabs8-1">1</a></li>
+                        <li><a href="#tabs8-2">2</a></li>
+                </ul>
+                <div id="tabs8-1">
+                        <p>Lorem ipsum</p>
+                        <p>Lorem ipsum</p>
+                        <p>Lorem ipsum</p>
+                </div>
+                <div id="tabs8-2">
+                        <p>Lorem ipsum</p>
+                </div>
+        </div>
+</div>
+<div id="tabs9">
+        <ul>
+                <li>not a tab</li>
+                <li><a href="#tabs9-1">tab</a></li>
+        </ul>
+        <div id="tabs9-1"></div>
+</div>
+</div>
+</body>
+</html>

Compare Path:	Rev
With Path:	Rev