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

Remove broken jquery-ui

Browse source
This commit is contained in:
Mark Schouten 2016-08-05 12:56:15 +02:00
parent 39aa35f2aa
commit d3488a963e
718 changed files with 10 additions and 518340 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,26 +0,0 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>jQuery UI Widget 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( "widget" );
</script>
</head>
<body>
<div id="qunit"></div>
<div id="qunit-fixture">
</div>
</body>
</html>

271
jquery-ui/tests/unit/widget/animation.js vendored
View file

@ -1,271 +0,0 @@
define( [
"qunit",
"jquery",
"ui/widget"
], function( QUnit, $ ) {
QUnit.module( "widget animation", ( function() {
var show = $.fn.show,
fadeIn = $.fn.fadeIn,
slideDown = $.fn.slideDown;
return {
beforeEach: function() {
$.widget( "ui.testWidget", {
_create: function() {
this.element.hide();
},
show: function( fn ) {
this._show( this.element, this.options.show, fn );
}
} );
$.effects = { effect: { testEffect: $.noop } };
},
afterEach: function() {
delete $.ui.testWidget;
delete $.effects.effect.testEffect;
$.fn.show = show;
$.fn.fadeIn = fadeIn;
$.fn.slideDown = slideDown;
}
};
}() ) );
QUnit.test( "show: null", function( assert ) {
var ready = assert.async();
assert.expect( 4 );
var element = $( "#widget" ).testWidget(),
hasRun = false;
$.fn.show = function() {
assert.ok( true, "show called" );
assert.equal( arguments.length, 0, "no args passed to show" );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
QUnit.test( "show: true", function( assert ) {
var ready = assert.async();
assert.expect( 4 );
var element = $( "#widget" ).testWidget( {
show: true
} ),
hasRun = false;
$.fn.fadeIn = function( duration, easing, complete ) {
return this.queue( function( next ) {
assert.strictEqual( duration, undefined, "duration" );
assert.strictEqual( easing, undefined, "easing" );
complete();
next();
} );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
QUnit.test( "show: number", function( assert ) {
var ready = assert.async();
assert.expect( 4 );
var element = $( "#widget" ).testWidget( {
show: 123
} ),
hasRun = false;
$.fn.fadeIn = function( duration, easing, complete ) {
return this.queue( function( next ) {
assert.strictEqual( duration, 123, "duration" );
assert.strictEqual( easing, undefined, "easing" );
complete();
next();
} );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
QUnit.test( "show: core animation", function( assert ) {
var ready = assert.async();
assert.expect( 4 );
var element = $( "#widget" ).testWidget( {
show: "slideDown"
} ),
hasRun = false;
$.fn.slideDown = function( duration, easing, complete ) {
return this.queue( function( next ) {
assert.strictEqual( duration, undefined, "duration" );
assert.strictEqual( easing, undefined, "easing" );
complete();
next();
} );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
QUnit.test( "show: effect", function( assert ) {
var ready = assert.async();
assert.expect( 5 );
var element = $( "#widget" ).testWidget( {
show: "testEffect"
} ),
hasRun = false;
$.fn.show = function( options ) {
return this.queue( function( next ) {
assert.equal( options.effect, "testEffect", "effect" );
assert.ok( !( "duration" in options ), "duration" );
assert.ok( !( "easing" in options ), "easing" );
options.complete();
next();
} );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
QUnit.test( "show: object(core animation)", function( assert ) {
var ready = assert.async();
assert.expect( 4 );
var element = $( "#widget" ).testWidget( {
show: {
effect: "slideDown",
duration: 123,
easing: "testEasing"
}
} ),
hasRun = false;
$.fn.slideDown = function( duration, easing, complete ) {
return this.queue( function( next ) {
assert.equal( duration, 123, "duration" );
assert.equal( easing, "testEasing", "easing" );
complete();
next();
} );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
QUnit.test( "show: object(effect)", function( assert ) {
var ready = assert.async();
assert.expect( 3 );
var element = $( "#widget" ).testWidget( {
show: {
effect: "testEffect",
duration: 123,
easing: "testEasing"
}
} ),
hasRun = false;
$.fn.show = function( options ) {
return this.queue( function( next ) {
assert.deepEqual( options, {
effect: "testEffect",
duration: 123,
easing: "testEasing",
complete: options.complete
} );
options.complete();
next();
} );
};
element
.delay( 50 )
.queue( function( next ) {
assert.ok( !hasRun, "queue before show" );
next();
} )
.testWidget( "show", function() {
hasRun = true;
} )
.queue( function( next ) {
assert.ok( hasRun, "queue after show" );
ready();
next();
} );
} );
} );

147
jquery-ui/tests/unit/widget/classes.js vendored
View file

@ -1,147 +0,0 @@
define( [
"qunit",
"jquery",
"ui/widget"
], function( QUnit, $ ) {
QUnit.module( "widget factory classes", {
beforeEach: function() {
$.widget( "ui.classesWidget", {
options: {
classes: {
"ui-classes-widget": "ui-theme-widget",
"ui-classes-element": "ui-theme-element ui-theme-element-2"
}
},
_create: function() {
this.span = $( "<span>" )
.appendTo( this.element );
this.element.wrap( "<div>" );
this.wrapper = this.element.parent();
this._addClass( "ui-classes-element", "ui-core-element" )
._addClass( "ui-classes-element-2" )
._addClass( null, "ui-core-element-null" )
._addClass( this.span, null, "ui-core-span-null" )
._addClass( this.span, "ui-classes-span", "ui-core-span" )
._addClass( this.wrapper, "ui-classes-widget" );
},
toggleClasses: function( bool ) {
this._toggleClass( "ui-classes-element", "ui-core-element", bool )
._toggleClass( "ui-classes-element-2", null, bool )
._toggleClass( null, "ui-core-element-null", bool )
._toggleClass( this.span, null, "ui-core-span-null", bool )
._toggleClass( this.span, "ui-classes-span", "ui-core-span", bool )
._toggleClass( this.wrapper, "ui-classes-widget", null, bool );
},
removeClasses: function() {
this._removeClass( "ui-classes-element", "ui-core-element" )
._removeClass( "ui-classes-element-2" )
._removeClass( null, "ui-core-element-null" )
._removeClass( this.span, null, "ui-core-span-null" )
._removeClass( this.span, "ui-classes-span", "ui-core-span" )
._removeClass( this.wrapper, "ui-classes-widget" );
},
_destroy: function() {
this.span.remove();
this.element.unwrap();
}
} );
},
afterEach: function() {
delete $.ui.classesWidget;
delete $.fn.classesWidget;
}
} );
function elementHasClasses( widget, method, assert ) {
var toggle = method === "toggle" ? ( ", true" ) : "";
assert.hasClasses( widget, "ui-classes-element ui-theme-element ui-theme-element-2",
"_" + method + "Class works with ( keys, extra" + toggle + " )" );
assert.hasClasses( widget, "ui-classes-element-2",
"_" + method + "Class works with ( keys, null" + toggle + " )" );
assert.hasClasses( widget, "ui-core-element-null",
"_" + method + "Class works with ( null, extra" + toggle + " )" );
assert.hasClasses( widget.parent(), "ui-classes-widget ui-theme-widget",
"_" + method + "Class works with ( element, null, extra" + toggle + " )" );
assert.hasClasses( widget.find( "span" ), "ui-classes-span ui-core-span",
"_" + method + "Class works with ( element, keys, extra" + toggle + " )" );
assert.hasClasses( widget.find( "span" ), "ui-core-span-null",
"_" + method + "Class works with ( element, keys, null" + toggle + " )" );
}
function elementLacksClasses( widget, method, assert ) {
var toggle = method === "toggle" ? ( ", false" ) : "";
assert.lacksClasses( widget, "ui-classes-element ui-theme-element ui-theme-element-2",
"_" + method + "Class works with ( keys, extra" + toggle + " )" );
assert.lacksClasses( widget, "ui-classes-element-2",
"_" + method + "Class works with ( keys, null" + toggle + " )" );
assert.lacksClasses( widget, "ui-core-element-null",
"_" + method + "Class works with ( null, extra" + toggle + " )" );
assert.lacksClasses( widget.parent(), "ui-classes-widget ui-theme-widget",
"_" + method + "Class works with ( element, null, extra" + toggle + " )" );
assert.lacksClasses( widget.find( "span" ), "ui-classes-span ui-core-span",
"_" + method + "Class works with ( element, keys, extra" + toggle + " )" );
assert.lacksClasses( widget.find( "span" ), "ui-core-span-null",
"_" + method + "Class works with ( element, keys, null" + toggle + " )" );
}
QUnit.test( ".option() - classes setter", function( assert ) {
assert.expect( 11 );
var testWidget = $.ui.classesWidget();
elementHasClasses( testWidget.element, "add", assert );
testWidget.option( {
classes: {
"ui-classes-span": "custom-theme-span",
"ui-classes-widget": "ui-theme-widget custom-theme-widget",
"ui-classes-element": "ui-theme-element-2"
}
} );
assert.lacksClasses( testWidget.element, "ui-theme-element",
"Removing a class from the value removes the class" );
testWidget.option( "classes.ui-classes-element", "" );
assert.hasClasses( testWidget.element, "ui-classes-element",
"Setting to empty value leaves structure class" );
assert.lacksClasses( testWidget.element, "ui-theme-element-2",
"Setting empty value removes previous value classes" );
assert.hasClasses( testWidget.span, "ui-classes-span custom-theme-span",
"Adding a class to an empty value works as expected" );
assert.hasClasses( testWidget.wrapper, "ui-classes-widget custom-theme-widget",
"Appending a class to the current value works as expected" );
} );
QUnit.test( ".destroy() - class removal", function( assert ) {
assert.expect( 1 );
assert.domEqual( "#widget", function() {
$( "#widget" ).classesWidget().classesWidget( "destroy" );
} );
} );
QUnit.test( "._add/_remove/_toggleClass()", function( assert ) {
assert.expect( 24 );
var widget = $( "#widget" ).classesWidget();
elementHasClasses( widget, "add", assert );
widget.classesWidget( "toggleClasses", false );
elementLacksClasses( widget, "toggle", assert );
widget.classesWidget( "toggleClasses", true );
elementHasClasses( widget, "toggle", assert );
widget.classesWidget( "removeClasses" );
elementLacksClasses( widget, "remove", assert );
} );
} );

1648
jquery-ui/tests/unit/widget/core.js vendored
View file

File diff suppressed because it is too large Load diff

113
jquery-ui/tests/unit/widget/extend.js vendored
View file

@ -1,113 +0,0 @@
define( [
"qunit",
"jquery",
"ui/widget"
], function( QUnit, $ ) {
QUnit.test( "$.widget.extend()", function( assert ) {
assert.expect( 27 );
var ret, empty, optionsWithLength, optionsWithDate, myKlass, customObject, optionsWithCustomObject, nullUndef,
target, recursive, obj, input, output,
settings = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
options = { xnumber2: 1, xstring2: "x", xxx: "newstring" },
optionsCopy = { xnumber2: 1, xstring2: "x", xxx: "newstring" },
merged = { xnumber1: 5, xnumber2: 1, xstring1: "peter", xstring2: "x", xxx: "newstring" },
deep1 = { foo: { bar: true } },
deep2 = { foo: { baz: true }, foo2: document },
deep2copy = { foo: { baz: true }, foo2: document },
deepmerged = { foo: { bar: true, baz: true }, foo2: document },
arr = [ 1, 2, 3 ],
nestedarray = { arr: arr },
defaults = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
defaultsCopy = { xnumber1: 5, xnumber2: 7, xstring1: "peter", xstring2: "pan" },
options1 = { xnumber2: 1, xstring2: "x" },
options1Copy = { xnumber2: 1, xstring2: "x" },
options2 = { xstring2: "xx", xxx: "newstringx" },
options2Copy = { xstring2: "xx", xxx: "newstringx" },
merged2 = { xnumber1: 5, xnumber2: 1, xstring1: "peter", xstring2: "xx", xxx: "newstringx" };
$.widget.extend( settings, options );
assert.deepEqual( settings, merged, "Check if extended: settings must be extended" );
assert.deepEqual( options, optionsCopy, "Check if not modified: options must not be modified" );
$.widget.extend( deep1, deep2 );
assert.deepEqual( deep1.foo, deepmerged.foo, "Check if foo: settings must be extended" );
assert.deepEqual( deep2.foo, deep2copy.foo, "Check if not deep2: options must not be modified" );
assert.equal( deep1.foo2, document, "Make sure that a deep clone was not attempted on the document" );
assert.strictEqual( $.widget.extend( {}, nestedarray ).arr, arr, "Don't clone arrays" );
assert.ok( $.isPlainObject( $.widget.extend( { arr: arr }, { arr: {} } ).arr ), "Cloned object heve to be an plain object" );
empty = {};
optionsWithLength = { foo: { length: -1 } };
$.widget.extend( empty, optionsWithLength );
assert.deepEqual( empty.foo, optionsWithLength.foo, "The length property must copy correctly" );
empty = {};
optionsWithDate = { foo: { date: new Date() } };
$.widget.extend( empty, optionsWithDate );
assert.deepEqual( empty.foo, optionsWithDate.foo, "Dates copy correctly" );
myKlass = function() {};
customObject = new myKlass();
optionsWithCustomObject = { foo: { date: customObject } };
empty = {};
$.widget.extend( empty, optionsWithCustomObject );
assert.strictEqual( empty.foo.date, customObject, "Custom objects copy correctly (no methods)" );
// Makes the class a little more realistic
myKlass.prototype = { someMethod: function() {} };
empty = {};
$.widget.extend( empty, optionsWithCustomObject );
assert.strictEqual( empty.foo.date, customObject, "Custom objects copy correctly" );
ret = $.widget.extend( { foo: 4 }, { foo: Number( 5 ) } );
assert.equal( ret.foo, 5, "Wrapped numbers copy correctly" );
nullUndef = $.widget.extend( {}, options, { xnumber2: null } );
assert.strictEqual( nullUndef.xnumber2, null, "Check to make sure null values are copied" );
nullUndef = $.widget.extend( {}, options, { xnumber2: undefined } );
assert.strictEqual( nullUndef.xnumber2, options.xnumber2, "Check to make sure undefined values are not copied" );
nullUndef = $.widget.extend( {}, options, { xnumber0: null } );
assert.strictEqual( nullUndef.xnumber0, null, "Check to make sure null values are inserted" );
target = {};
recursive = { foo:target, bar:5 };
$.widget.extend( target, recursive );
assert.deepEqual( target, { foo: {}, bar: 5 }, "Check to make sure a recursive obj doesn't go never-ending loop by not copying it over" );
ret = $.widget.extend( { foo: [] }, { foo: [ 0 ] } ); // 1907
assert.equal( ret.foo.length, 1, "Check to make sure a value with coersion 'false' copies over when necessary to fix #1907" );
ret = $.widget.extend( { foo: "1,2,3" }, { foo: [ 1, 2, 3 ] } );
assert.deepEqual( ret.foo, [ 1, 2, 3 ], "Properly extend a string to array." );
ret = $.widget.extend( { foo: "1,2,3" }, { foo: { to: "object" } } );
assert.deepEqual( ret.foo, { to: "object" }, "Properly extend a string to object." );
ret = $.widget.extend( { foo: "bar" }, { foo: null } );
assert.strictEqual( ret.foo, null, "Make sure a null value doesn't crash with deep extend, for #1908" );
obj = { foo: null };
$.widget.extend( obj, { foo:"notnull" } );
assert.equal( obj.foo, "notnull", "Make sure a null value can be overwritten" );
settings = $.widget.extend( {}, defaults, options1, options2 );
assert.deepEqual( settings, merged2, "Check if extended: settings must be extended" );
assert.deepEqual( defaults, defaultsCopy, "Check if not modified: options1 must not be modified" );
assert.deepEqual( options1, options1Copy, "Check if not modified: options1 must not be modified" );
assert.deepEqual( options2, options2Copy, "Check if not modified: options2 must not be modified" );
input = {
key: [ 1, 2, 3 ]
};
output = $.widget.extend( {}, input );
assert.deepEqual( input, output, "don't clone arrays" );
input.key[ 0 ] = 10;
assert.deepEqual( input, output, "don't clone arrays" );
} );
} );

25
jquery-ui/tests/unit/widget/widget.html
View file

@ -1,25 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>jQuery UI Widget Test Suite</title>
<script src="../../../external/requirejs/require.js"></script>
<script src="../../lib/css.js" data-modules="core"></script>
<script src="../../lib/bootstrap.js" data-modules="core extend animation classes">
</script>
</head>
<body>
<div id="qunit"></div>
<div id="qunit-fixture">
<div id="widget-wrapper">
<div id="widget">
<div>...</div>
</div>
</div>
</div>
</body>
</html>