" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
// Otherwise use the full result
responseText );
@@ -60,14 +60,14 @@ jQuery.fn.load = function( url, params, callback ) {
// If the request succeeds, this function gets "data", "status", "jqXHR"
// but they are ignored because response was set above.
// If it fails, this function gets "jqXHR", "status", "error"
- }).always( callback && function( jqXHR, status ) {
+ } ).always( callback && function( jqXHR, status ) {
self.each( function() {
callback.apply( self, response || [ jqXHR.responseText, status, jqXHR ] );
- });
- });
+ } );
+ } );
}
return this;
};
-});
+} );
diff --git a/src/ajax/parseJSON.js b/src/ajax/parseJSON.js
index 3a96d15b9..11918b06d 100644
--- a/src/ajax/parseJSON.js
+++ b/src/ajax/parseJSON.js
@@ -1,4 +1,4 @@
-define([
+define( [
"../core"
], function( jQuery ) {
@@ -10,4 +10,4 @@ jQuery.parseJSON = function( data ) {
return jQuery.parseJSON;
-});
+} );
diff --git a/src/ajax/parseXML.js b/src/ajax/parseXML.js
index 962dc8887..6599aaf5b 100644
--- a/src/ajax/parseXML.js
+++ b/src/ajax/parseXML.js
@@ -1,4 +1,4 @@
-define([
+define( [
"../core"
], function( jQuery ) {
@@ -24,4 +24,4 @@ jQuery.parseXML = function( data ) {
return jQuery.parseXML;
-});
+} );
diff --git a/src/ajax/script.js b/src/ajax/script.js
index ede551708..60b1fb6b0 100644
--- a/src/ajax/script.js
+++ b/src/ajax/script.js
@@ -1,11 +1,11 @@
-define([
+define( [
"../core",
"../var/document",
"../ajax"
], function( jQuery, document ) {
// Install script dataType
-jQuery.ajaxSetup({
+jQuery.ajaxSetup( {
accepts: {
script: "text/javascript, application/javascript, " +
"application/ecmascript, application/x-ecmascript"
@@ -19,7 +19,7 @@ jQuery.ajaxSetup({
return text;
}
}
-});
+} );
// Handle cache's special case and crossDomain
jQuery.ajaxPrefilter( "script", function( s ) {
@@ -29,19 +29,20 @@ jQuery.ajaxPrefilter( "script", function( s ) {
if ( s.crossDomain ) {
s.type = "GET";
}
-});
+} );
// Bind script tag hack transport
jQuery.ajaxTransport( "script", function( s ) {
+
// This transport only deals with cross domain requests
if ( s.crossDomain ) {
var script, callback;
return {
send: function( _, complete ) {
- script = jQuery("");
+ jQuery( "#qunit-fixture" ).append( "" );
- jQuery( document ).off("ajaxStart ajaxStop");
- });
+ jQuery( document ).off( "ajaxStart ajaxStop" );
+ } );
QUnit.asyncTest( "jQuery#load() - always use GET method even if it overrided through ajaxSetup (#11264)", 1, function( assert ) {
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
type: "POST"
- });
+ } );
jQuery( "#qunit-fixture" ).load( "data/ajax/method.php", function( method ) {
assert.equal( method, "GET" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "#11402 - jQuery.domManip() - script in comments are properly evaluated", 2, function() {
- jQuery("#qunit-fixture").load( "data/cleanScript.html", start );
- });
+ jQuery( "#qunit-fixture" ).load( "data/cleanScript.html", start );
+ } );
//----------- jQuery.get()
QUnit.asyncTest( "jQuery.get( String, Hash, Function ) - parse xml and use text() on nodes", 2, function( assert ) {
- jQuery.get( url("data/dashboard.xml"), function( xml ) {
+ jQuery.get( url( "data/dashboard.xml" ), function( xml ) {
var content = [];
- jQuery( "tab", xml ).each(function() {
+ jQuery( "tab", xml ).each( function() {
content.push( jQuery( this ).text() );
- });
+ } );
assert.strictEqual( content[ 0 ], "blabla", "Check first tab" );
assert.strictEqual( content[ 1 ], "blublu", "Check second tab" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "#8277 - jQuery.get( String, Function ) - data in ajaxSettings", 1, function( assert ) {
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
data: "helloworld"
- });
- jQuery.get( url("data/echoQuery.php"), function( data ) {
+ } );
+ jQuery.get( url( "data/echoQuery.php" ), function( data ) {
assert.ok( /helloworld$/.test( data ), "Data from ajaxSettings was used" );
QUnit.start();
- });
- });
+ } );
+ } );
//----------- jQuery.getJSON()
QUnit.asyncTest( "jQuery.getJSON( String, Hash, Function ) - JSON array", 5, function( assert ) {
jQuery.getJSON(
- url("data/json.php"),
+ url( "data/json.php" ),
{
"json": "array"
},
function( json ) {
assert.ok( json.length >= 2, "Check length" );
- assert.strictEqual( json[ 0 ]["name"], "John", "Check JSON: first, name" );
- assert.strictEqual( json[ 0 ]["age"], 21, "Check JSON: first, age" );
- assert.strictEqual( json[ 1 ]["name"], "Peter", "Check JSON: second, name" );
- assert.strictEqual( json[ 1 ]["age"], 25, "Check JSON: second, age" );
+ assert.strictEqual( json[ 0 ][ "name" ], "John", "Check JSON: first, name" );
+ assert.strictEqual( json[ 0 ][ "age" ], 21, "Check JSON: first, age" );
+ assert.strictEqual( json[ 1 ][ "name" ], "Peter", "Check JSON: second, name" );
+ assert.strictEqual( json[ 1 ][ "age" ], 25, "Check JSON: second, age" );
QUnit.start();
}
);
- });
+ } );
QUnit.asyncTest( "jQuery.getJSON( String, Function ) - JSON object", 2, function( assert ) {
- jQuery.getJSON( url("data/json.php"), function( json ) {
- if ( json && json["data"] ) {
- assert.strictEqual( json["data"]["lang"], "en", "Check JSON: lang" );
- assert.strictEqual( json["data"].length, 25, "Check JSON: length" );
+ jQuery.getJSON( url( "data/json.php" ), function( json ) {
+ if ( json && json[ "data" ] ) {
+ assert.strictEqual( json[ "data" ][ "lang" ], "en", "Check JSON: lang" );
+ assert.strictEqual( json[ "data" ].length, 25, "Check JSON: length" );
QUnit.start();
}
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.getJSON( String, Function ) - JSON object with absolute url to local content", 2, function( assert ) {
jQuery.getJSON( url( window.location.href.replace( /[^\/]*$/, "" ) + "data/json.php" ), function( json ) {
assert.strictEqual( json.data.lang, "en", "Check JSON: lang" );
assert.strictEqual( json.data.length, 25, "Check JSON: length" );
QUnit.start();
- });
- });
+ } );
+ } );
//----------- jQuery.getScript()
QUnit.asyncTest( "jQuery.getScript( String, Function ) - with callback", 2, function( assert ) {
- Globals.register("testBar");
- jQuery.getScript( url("data/testbar.php"), function() {
- assert.strictEqual( window["testBar"], "bar", "Check if script was evaluated" );
+ Globals.register( "testBar" );
+ jQuery.getScript( url( "data/testbar.php" ), function() {
+ assert.strictEqual( window[ "testBar" ], "bar", "Check if script was evaluated" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.getScript( String, Function ) - no callback", 1, function() {
- Globals.register("testBar");
- jQuery.getScript( url("data/testbar.php") ).done( start );
- });
+ Globals.register( "testBar" );
+ jQuery.getScript( url( "data/testbar.php" ) ).done( start );
+ } );
QUnit.asyncTest( "#8082 - jQuery.getScript( String, Function ) - source as responseText", 2, function( assert ) {
- Globals.register("testBar");
- jQuery.getScript( url("data/testbar.php"), function( data, _, jqXHR ) {
+ Globals.register( "testBar" );
+ jQuery.getScript( url( "data/testbar.php" ), function( data, _, jqXHR ) {
assert.strictEqual( data, jqXHR.responseText, "Same-domain script requests returns the source of the script" );
QUnit.start();
- });
- });
+ } );
+ } );
// //----------- jQuery.fn.load()
// check if load can be called with only url
QUnit.asyncTest( "jQuery.fn.load( String )", 2, function( assert ) {
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
beforeSend: function() {
assert.strictEqual( this.type, "GET", "no data means GET request" );
}
- });
- jQuery("#first").load( "data/name.html", start );
- });
+ } );
+ jQuery( "#first" ).load( "data/name.html", start );
+ } );
QUnit.test( "jQuery.fn.load() - 404 error callbacks", function( assert ) {
assert.expect( 6 );
@@ -1961,134 +1965,134 @@ QUnit.module( "ajax", {
addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxError", assert )();
jQuery( document ).ajaxStop( done );
- jQuery("
").load( "data/404.html", function() {
+ jQuery( "
" ).load( "data/404.html", function() {
assert.ok( true, "complete" );
- });
- });
+ } );
+ } );
// check if load can be called with url and null data
QUnit.asyncTest( "jQuery.fn.load( String, null )", 2, function( assert ) {
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
beforeSend: function() {
assert.strictEqual( this.type, "GET", "no data means GET request" );
}
- });
- jQuery("#first").load( "data/name.html", null, start );
- });
+ } );
+ jQuery( "#first" ).load( "data/name.html", null, start );
+ } );
// check if load can be called with url and undefined data
QUnit.asyncTest( "jQuery.fn.load( String, undefined )", 2, function( assert ) {
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
beforeSend: function() {
assert.strictEqual( this.type, "GET", "no data means GET request" );
}
- });
- jQuery("#first").load( "data/name.html", undefined, start );
- });
+ } );
+ jQuery( "#first" ).load( "data/name.html", undefined, start );
+ } );
// check if load can be called with only url
QUnit.asyncTest( "jQuery.fn.load( URL_SELECTOR )", 1, function( assert ) {
- jQuery("#first").load( "data/test3.html div.user", function() {
- assert.strictEqual( jQuery( this ).children("div").length, 2, "Verify that specific elements were injected" );
+ jQuery( "#first" ).load( "data/test3.html div.user", function() {
+ assert.strictEqual( jQuery( this ).children( "div" ).length, 2, "Verify that specific elements were injected" );
QUnit.start();
- });
- });
+ } );
+ } );
// Selector should be trimmed to avoid leading spaces (#14773)
QUnit.asyncTest( "jQuery.fn.load( URL_SELECTOR with spaces )", 1, function( assert ) {
- jQuery("#first").load( "data/test3.html #superuser ", function() {
- assert.strictEqual( jQuery( this ).children("div").length, 1, "Verify that specific elements were injected" );
+ jQuery( "#first" ).load( "data/test3.html #superuser ", function() {
+ assert.strictEqual( jQuery( this ).children( "div" ).length, 1, "Verify that specific elements were injected" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.fn.load( String, Function ) - simple: inject text into DOM", 2, function( assert ) {
- jQuery("#first").load( url("data/name.html"), function() {
- assert.ok( /^ERROR/.test(jQuery("#first").text()), "Check if content was injected into the DOM" );
+ jQuery( "#first" ).load( url( "data/name.html" ), function() {
+ assert.ok( /^ERROR/.test( jQuery( "#first" ).text() ), "Check if content was injected into the DOM" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.fn.load( String, Function ) - check scripts", 7, function( assert ) {
var verifyEvaluation = function() {
- assert.strictEqual( window["testBar"], "bar", "Check if script src was evaluated after load" );
- assert.strictEqual( jQuery("#ap").html(), "bar", "Check if script evaluation has modified DOM");
+ assert.strictEqual( window[ "testBar" ], "bar", "Check if script src was evaluated after load" );
+ assert.strictEqual( jQuery( "#ap" ).html(), "bar", "Check if script evaluation has modified DOM" );
QUnit.start();
};
- Globals.register("testFoo");
- Globals.register("testBar");
+ Globals.register( "testFoo" );
+ Globals.register( "testBar" );
- jQuery("#first").load( url("data/test.html"), function() {
- assert.ok( jQuery("#first").html().match( /^html text/ ), "Check content after loading html" );
- assert.strictEqual( jQuery("#foo").html(), "foo", "Check if script evaluation has modified DOM" );
- assert.strictEqual( window["testFoo"], "foo", "Check if script was evaluated after load" );
+ jQuery( "#first" ).load( url( "data/test.html" ), function() {
+ assert.ok( jQuery( "#first" ).html().match( /^html text/ ), "Check content after loading html" );
+ assert.strictEqual( jQuery( "#foo" ).html(), "foo", "Check if script evaluation has modified DOM" );
+ assert.strictEqual( window[ "testFoo" ], "foo", "Check if script was evaluated after load" );
setTimeout( verifyEvaluation, 600 );
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.fn.load( String, Function ) - check file with only a script tag", 3, function( assert ) {
- Globals.register("testFoo");
+ Globals.register( "testFoo" );
- jQuery("#first").load( url("data/test2.html"), function() {
- assert.strictEqual( jQuery("#foo").html(), "foo", "Check if script evaluation has modified DOM");
- assert.strictEqual( window["testFoo"], "foo", "Check if script was evaluated after load" );
+ jQuery( "#first" ).load( url( "data/test2.html" ), function() {
+ assert.strictEqual( jQuery( "#foo" ).html(), "foo", "Check if script evaluation has modified DOM" );
+ assert.strictEqual( window[ "testFoo" ], "foo", "Check if script was evaluated after load" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.fn.load( String, Function ) - dataFilter in ajaxSettings", 2, function( assert ) {
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
dataFilter: function() {
return "Hello World";
}
- });
- jQuery("
").load( url("data/name.html"), function( responseText ) {
+ } );
+ jQuery( "
" ).load( url( "data/name.html" ), function( responseText ) {
assert.strictEqual( jQuery( this ).html(), "Hello World", "Test div was filled with filtered data" );
assert.strictEqual( responseText, "Hello World", "Test callback receives filtered data" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.asyncTest( "jQuery.fn.load( String, Object, Function )", 2, function( assert ) {
- jQuery("
").load( url("data/params_html.php"), {
+ jQuery( "
" ).load( url( "data/params_html.php" ), {
"foo": 3,
"bar": "ok"
}, function() {
- var $post = jQuery( this ).find("#post");
- assert.strictEqual( $post.find("#foo").text(), "3", "Check if a hash of data is passed correctly" );
- assert.strictEqual( $post.find("#bar").text(), "ok", "Check if a hash of data is passed correctly" );
+ var $post = jQuery( this ).find( "#post" );
+ assert.strictEqual( $post.find( "#foo" ).text(), "3", "Check if a hash of data is passed correctly" );
+ assert.strictEqual( $post.find( "#bar" ).text(), "ok", "Check if a hash of data is passed correctly" );
QUnit.start();
- });
- });
+ } );
+ } );
QUnit.test( "jQuery.fn.load( String, String, Function )", 2, function( assert ) {
var done = assert.async();
- jQuery("
").load( url("data/params_html.php"), "foo=3&bar=ok", function() {
- var $get = jQuery( this ).find("#get");
- assert.strictEqual( $get.find("#foo").text(), "3", "Check if a string of data is passed correctly" );
- assert.strictEqual( $get.find("#bar").text(), "ok", "Check if a of data is passed correctly" );
+ jQuery( "
" ).load( url( "data/params_html.php" ), "foo=3&bar=ok", function() {
+ var $get = jQuery( this ).find( "#get" );
+ assert.strictEqual( $get.find( "#foo" ).text(), "3", "Check if a string of data is passed correctly" );
+ assert.strictEqual( $get.find( "#bar" ).text(), "ok", "Check if a of data is passed correctly" );
done();
- });
- });
+ } );
+ } );
QUnit.test( "jQuery.fn.load() - callbacks get the correct parameters", 8, function( assert ) {
var completeArgs = {};
var done = assert.async();
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
success: function( _, status, jqXHR ) {
completeArgs[ this.url ] = [ jqXHR.responseText, status, jqXHR ];
},
error: function( jqXHR, status ) {
completeArgs[ this.url ] = [ jqXHR.responseText, status, jqXHR ];
}
- });
+ } );
jQuery.when.apply(
jQuery,
- jQuery.map([
+ jQuery.map( [
{
type: "success",
url: "data/echoQuery.php?arg=pop"
@@ -2099,33 +2103,33 @@ QUnit.module( "ajax", {
}
],
function( options ) {
- return jQuery.Deferred(function( defer ) {
- jQuery("#foo").load( options.url, function() {
+ return jQuery.Deferred( function( defer ) {
+ jQuery( "#foo" ).load( options.url, function() {
var args = arguments;
assert.strictEqual( completeArgs[ options.url ].length, args.length, "same number of arguments (" + options.type + ")" );
jQuery.each( completeArgs[ options.url ], function( i, value ) {
assert.strictEqual( args[ i ], value, "argument #" + i + " is the same (" + options.type + ")" );
- });
+ } );
defer.resolve();
- });
- });
- })
+ } );
+ } );
+ } )
).always( done );
- });
+ } );
QUnit.test( "#2046 - jQuery.fn.load( String, Function ) with ajaxSetup on dataType json", 1, function( assert ) {
var done = assert.async();
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
dataType: "json"
- });
- jQuery( document ).ajaxComplete(function( e, xml, s ) {
+ } );
+ jQuery( document ).ajaxComplete( function( e, xml, s ) {
assert.strictEqual( s.dataType, "html", "Verify the load() dataType was html" );
- jQuery( document ).off("ajaxComplete");
+ jQuery( document ).off( "ajaxComplete" );
done();
- });
- jQuery("#first").load("data/test3.html");
- });
+ } );
+ jQuery( "#first" ).load( "data/test3.html" );
+ } );
QUnit.test( "#10524 - jQuery.fn.load() - data specified in ajaxSettings is merged in", 1, function( assert ) {
var done = assert.async();
@@ -2133,17 +2137,17 @@ QUnit.module( "ajax", {
var data = {
"baz": 1
};
- jQuery.ajaxSetup({
+ jQuery.ajaxSetup( {
data: {
"foo": "bar"
}
- });
- jQuery("#foo").load( "data/echoQuery.php", data );
- jQuery( document ).ajaxComplete(function( event, jqXHR, options ) {
- assert.ok( ~options.data.indexOf("foo=bar"), "Data from ajaxSettings was used" );
+ } );
+ jQuery( "#foo" ).load( "data/echoQuery.php", data );
+ jQuery( document ).ajaxComplete( function( event, jqXHR, options ) {
+ assert.ok( ~options.data.indexOf( "foo=bar" ), "Data from ajaxSettings was used" );
done();
- });
- });
+ } );
+ } );
// //----------- jQuery.post()
@@ -2152,20 +2156,20 @@ QUnit.module( "ajax", {
jQuery.when(
jQuery.post(
- url("data/name.php"),
+ url( "data/name.php" ),
{
xml: "5-2",
length: 3
},
function( xml ) {
- jQuery( "math", xml ).each(function() {
+ jQuery( "math", xml ).each( function() {
assert.strictEqual( jQuery( "calculation", this ).text(), "5-2", "Check for XML" );
assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
- });
+ } );
}
),
- jQuery.ajax({
- url: url("data/echoData.php"),
+ jQuery.ajax( {
+ url: url( "data/echoData.php" ),
type: "POST",
data: {
"test": {
@@ -2176,66 +2180,66 @@ QUnit.module( "ajax", {
success: function( data ) {
assert.strictEqual( data, "test%5Blength%5D=7&test%5Bfoo%5D=bar", "Check if a sub-object with a length param is serialized correctly" );
}
- })
- ).always(function() {
+ } )
+ ).always( function() {
done();
- });
- });
+ } );
+ } );
QUnit.test( "jQuery.post( String, Hash, Function ) - simple with xml", 4, function( assert ) {
var done = assert.async();
jQuery.when(
jQuery.post(
- url("data/name.php"),
+ url( "data/name.php" ),
{
"xml": "5-2"
},
function( xml ) {
- jQuery( "math", xml ).each(function() {
+ jQuery( "math", xml ).each( function() {
assert.strictEqual( jQuery( "calculation", this ).text(), "5-2", "Check for XML" );
assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
- });
+ } );
}
),
- jQuery.post( url("data/name.php?xml=5-2"), {}, function( xml ) {
- jQuery( "math", xml ).each(function() {
+ jQuery.post( url( "data/name.php?xml=5-2" ), {}, function( xml ) {
+ jQuery( "math", xml ).each( function() {
assert.strictEqual( jQuery( "calculation", this ).text(), "5-2", "Check for XML" );
assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
- });
- })
- ).always(function() {
+ } );
+ } )
+ ).always( function() {
done();
- });
- });
+ } );
+ } );
QUnit.test( "jQuery[get|post]( options ) - simple with xml", 2, function( assert ) {
var done = assert.async();
jQuery.when.apply( jQuery,
- jQuery.map( [ "get", "post" ] , function( method ) {
- return jQuery[ method ]({
+ jQuery.map( [ "get", "post" ], function( method ) {
+ return jQuery[ method ]( {
url: url( "data/name.php" ),
data: {
"xml": "5-2"
},
success: function( xml ) {
- jQuery( "math", xml ).each(function() {
+ jQuery( "math", xml ).each( function() {
assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
- });
+ } );
}
- });
- })
- ).always(function() {
+ } );
+ } )
+ ).always( function() {
done();
- });
- });
+ } );
+ } );
//----------- jQuery.active
QUnit.test( "jQuery.active", function( assert ) {
assert.expect( 1 );
assert.ok( jQuery.active === 0, "ajax active counter should be zero: " + jQuery.active );
- });
+ } );
-})();
+} )();
diff --git a/test/unit/attributes.js b/test/unit/attributes.js
index 6d8848a3e..59c8ec50b 100644
--- a/test/unit/attributes.js
+++ b/test/unit/attributes.js
@@ -1,6 +1,6 @@
QUnit.module( "attributes", {
teardown: moduleTeardown
-});
+} );
function bareObj( value ) {
return value;
@@ -47,7 +47,7 @@ QUnit.test( "jQuery.propFix integrity test", function( assert ) {
};
assert.deepEqual( props, jQuery.propFix, "jQuery.propFix passes integrity check" );
-});
+} );
QUnit.test( "attr(String)", function( assert ) {
assert.expect( 50 );
@@ -56,199 +56,200 @@ QUnit.test( "attr(String)", function( assert ) {
select, optgroup, option, $img, styleElem,
$button, $form, $a;
- assert.equal( jQuery("#text1").attr("type"), "text", "Check for type attribute" );
- assert.equal( jQuery("#radio1").attr("type"), "radio", "Check for type attribute" );
- assert.equal( jQuery("#check1").attr("type"), "checkbox", "Check for type attribute" );
- assert.equal( jQuery("#simon1").attr("rel"), "bookmark", "Check for rel attribute" );
- assert.equal( jQuery("#google").attr("title"), "Google!", "Check for title attribute" );
- assert.equal( jQuery("#mark").attr("hreflang"), "en", "Check for hreflang attribute" );
- assert.equal( jQuery("#en").attr("lang"), "en", "Check for lang attribute" );
- assert.equal( jQuery("#simon").attr("class"), "blog link", "Check for class attribute" );
- assert.equal( jQuery("#name").attr("name"), "name", "Check for name attribute" );
- assert.equal( jQuery("#text1").attr("name"), "action", "Check for name attribute" );
- assert.ok( jQuery("#form").attr("action").indexOf("formaction") >= 0, "Check for action attribute" );
- assert.equal( jQuery("#text1").attr("value", "t").attr("value"), "t", "Check setting the value attribute" );
- assert.equal( jQuery("#text1").attr("value", "").attr("value"), "", "Check setting the value attribute to empty string" );
- assert.equal( jQuery("
").attr("value"), "t", "Check setting custom attr named 'value' on a div" );
- assert.equal( jQuery("#form").attr("blah", "blah").attr("blah"), "blah", "Set non-existent attribute on a form" );
- assert.equal( jQuery("#foo").attr("height"), undefined, "Non existent height attribute should return undefined" );
+ assert.equal( jQuery( "#text1" ).attr( "type" ), "text", "Check for type attribute" );
+ assert.equal( jQuery( "#radio1" ).attr( "type" ), "radio", "Check for type attribute" );
+ assert.equal( jQuery( "#check1" ).attr( "type" ), "checkbox", "Check for type attribute" );
+ assert.equal( jQuery( "#simon1" ).attr( "rel" ), "bookmark", "Check for rel attribute" );
+ assert.equal( jQuery( "#google" ).attr( "title" ), "Google!", "Check for title attribute" );
+ assert.equal( jQuery( "#mark" ).attr( "hreflang" ), "en", "Check for hreflang attribute" );
+ assert.equal( jQuery( "#en" ).attr( "lang" ), "en", "Check for lang attribute" );
+ assert.equal( jQuery( "#simon" ).attr( "class" ), "blog link", "Check for class attribute" );
+ assert.equal( jQuery( "#name" ).attr( "name" ), "name", "Check for name attribute" );
+ assert.equal( jQuery( "#text1" ).attr( "name" ), "action", "Check for name attribute" );
+ assert.ok( jQuery( "#form" ).attr( "action" ).indexOf( "formaction" ) >= 0, "Check for action attribute" );
+ assert.equal( jQuery( "#text1" ).attr( "value", "t" ).attr( "value" ), "t", "Check setting the value attribute" );
+ assert.equal( jQuery( "#text1" ).attr( "value", "" ).attr( "value" ), "", "Check setting the value attribute to empty string" );
+ assert.equal( jQuery( "
" ).attr( "value" ), "t", "Check setting custom attr named 'value' on a div" );
+ assert.equal( jQuery( "#form" ).attr( "blah", "blah" ).attr( "blah" ), "blah", "Set non-existent attribute on a form" );
+ assert.equal( jQuery( "#foo" ).attr( "height" ), undefined, "Non existent height attribute should return undefined" );
// [7472] & [3113] (form contains an input with name="action" or name="id")
- extras = jQuery("
").appendTo("#testForm");
- assert.equal( jQuery("#form").attr("action","newformaction").attr("action"), "newformaction", "Check that action attribute was changed" );
- assert.equal( jQuery("#testForm").attr("target"), undefined, "Retrieving target does not equal the input with name=target" );
- assert.equal( jQuery("#testForm").attr("target", "newTarget").attr("target"), "newTarget", "Set target successfully on a form" );
- assert.equal( jQuery("#testForm").removeAttr("id").attr("id"), undefined, "Retrieving id does not equal the input with name=id after id is removed [#7472]" );
+ extras = jQuery( "
" ).appendTo( "#testForm" );
+ assert.equal( jQuery( "#form" ).attr( "action", "newformaction" ).attr( "action" ), "newformaction", "Check that action attribute was changed" );
+ assert.equal( jQuery( "#testForm" ).attr( "target" ), undefined, "Retrieving target does not equal the input with name=target" );
+ assert.equal( jQuery( "#testForm" ).attr( "target", "newTarget" ).attr( "target" ), "newTarget", "Set target successfully on a form" );
+ assert.equal( jQuery( "#testForm" ).removeAttr( "id" ).attr( "id" ), undefined, "Retrieving id does not equal the input with name=id after id is removed [#7472]" );
+
// Bug #3685 (form contains input with name="name")
- assert.equal( jQuery("#testForm").attr("name"), undefined, "Retrieving name does not retrieve input with name=name" );
+ assert.equal( jQuery( "#testForm" ).attr( "name" ), undefined, "Retrieving name does not retrieve input with name=name" );
extras.remove();
- assert.equal( jQuery("#text1").attr("maxlength"), "30", "Check for maxlength attribute" );
- assert.equal( jQuery("#text1").attr("maxLength"), "30", "Check for maxLength attribute" );
- assert.equal( jQuery("#area1").attr("maxLength"), "30", "Check for maxLength attribute" );
+ assert.equal( jQuery( "#text1" ).attr( "maxlength" ), "30", "Check for maxlength attribute" );
+ assert.equal( jQuery( "#text1" ).attr( "maxLength" ), "30", "Check for maxLength attribute" );
+ assert.equal( jQuery( "#area1" ).attr( "maxLength" ), "30", "Check for maxLength attribute" );
// using innerHTML in IE causes href attribute to be serialized to the full path
- jQuery("
").attr({
+ jQuery( "
" ).attr( {
"id": "tAnchor5",
"href": "#5"
- }).appendTo("#qunit-fixture");
- assert.equal( jQuery("#tAnchor5").attr("href"), "#5", "Check for non-absolute href (an anchor)" );
- jQuery("
").appendTo("#qunit-fixture");
- assert.equal( jQuery("#tAnchor5").prop("href"), jQuery("#tAnchor6").prop("href"), "Check for absolute href prop on an anchor" );
+ } ).appendTo( "#qunit-fixture" );
+ assert.equal( jQuery( "#tAnchor5" ).attr( "href" ), "#5", "Check for non-absolute href (an anchor)" );
+ jQuery( "
" ).appendTo( "#qunit-fixture" );
+ assert.equal( jQuery( "#tAnchor5" ).prop( "href" ), jQuery( "#tAnchor6" ).prop( "href" ), "Check for absolute href prop on an anchor" );
- jQuery("").appendTo("#qunit-fixture");
- assert.equal( jQuery("#tAnchor5").prop("href"), jQuery("#scriptSrc").prop("src"), "Check for absolute src prop on a script" );
+ jQuery( "" ).appendTo( "#qunit-fixture" );
+ assert.equal( jQuery( "#tAnchor5" ).prop( "href" ), jQuery( "#scriptSrc" ).prop( "src" ), "Check for absolute src prop on a script" );
// list attribute is readonly by default in browsers that support it
- jQuery("#list-test").attr( "list", "datalist" );
- assert.equal( jQuery("#list-test").attr("list"), "datalist", "Check setting list attribute" );
+ jQuery( "#list-test" ).attr( "list", "datalist" );
+ assert.equal( jQuery( "#list-test" ).attr( "list" ), "datalist", "Check setting list attribute" );
// Related to [5574] and [5683]
body = document.body;
$body = jQuery( body );
- assert.strictEqual( $body.attr("foo"), undefined, "Make sure that a non existent attribute returns undefined" );
+ assert.strictEqual( $body.attr( "foo" ), undefined, "Make sure that a non existent attribute returns undefined" );
body.setAttribute( "foo", "baz" );
- assert.equal( $body.attr("foo"), "baz", "Make sure the dom attribute is retrieved when no expando is found" );
+ assert.equal( $body.attr( "foo" ), "baz", "Make sure the dom attribute is retrieved when no expando is found" );
- $body.attr( "foo","cool" );
- assert.equal( $body.attr("foo"), "cool", "Make sure that setting works well when both expando and dom attribute are available" );
+ $body.attr( "foo", "cool" );
+ assert.equal( $body.attr( "foo" ), "cool", "Make sure that setting works well when both expando and dom attribute are available" );
- body.removeAttribute("foo"); // Cleanup
+ body.removeAttribute( "foo" ); // Cleanup
- select = document.createElement("select");
- optgroup = document.createElement("optgroup");
- option = document.createElement("option");
+ select = document.createElement( "select" );
+ optgroup = document.createElement( "optgroup" );
+ option = document.createElement( "option" );
optgroup.appendChild( option );
select.appendChild( optgroup );
- assert.equal( jQuery( option ).prop("selected"), true, "Make sure that a single option is selected, even when in an optgroup." );
+ assert.equal( jQuery( option ).prop( "selected" ), true, "Make sure that a single option is selected, even when in an optgroup." );
- $img = jQuery("
").appendTo("body");
- assert.equal( $img.attr("width"), "215", "Retrieve width attribute an an element with display:none." );
- assert.equal( $img.attr("height"), "53", "Retrieve height attribute an an element with display:none." );
+ $img = jQuery( "
" ).appendTo( "body" );
+ assert.equal( $img.attr( "width" ), "215", "Retrieve width attribute an an element with display:none." );
+ assert.equal( $img.attr( "height" ), "53", "Retrieve height attribute an an element with display:none." );
// Check for style support
- styleElem = jQuery("
").appendTo("#qunit-fixture").css({
+ styleElem = jQuery( "
" ).appendTo( "#qunit-fixture" ).css( {
background: "url(UPPERlower.gif)"
- });
- assert.ok( !!~styleElem.attr("style").indexOf("UPPERlower.gif"), "Check style attribute getter" );
- assert.ok( !!~styleElem.attr("style", "position:absolute;").attr("style").indexOf("absolute"), "Check style setter" );
+ } );
+ assert.ok( !!~styleElem.attr( "style" ).indexOf( "UPPERlower.gif" ), "Check style attribute getter" );
+ assert.ok( !!~styleElem.attr( "style", "position:absolute;" ).attr( "style" ).indexOf( "absolute" ), "Check style setter" );
// Check value on button element (#1954)
- $button = jQuery("
text ").insertAfter("#button");
- assert.strictEqual( $button.attr("value"), undefined, "Absence of value attribute on a button" );
- assert.equal( $button.attr( "value", "foobar" ).attr("value"), "foobar", "Value attribute on a button does not return innerHTML" );
- assert.equal( $button.attr("value", "baz").html(), "text", "Setting the value attribute does not change innerHTML" );
+ $button = jQuery( "
text " ).insertAfter( "#button" );
+ assert.strictEqual( $button.attr( "value" ), undefined, "Absence of value attribute on a button" );
+ assert.equal( $button.attr( "value", "foobar" ).attr( "value" ), "foobar", "Value attribute on a button does not return innerHTML" );
+ assert.equal( $button.attr( "value", "baz" ).html(), "text", "Setting the value attribute does not change innerHTML" );
// Attributes with a colon on a table element (#1591)
- assert.equal( jQuery("#table").attr("test:attrib"), undefined, "Retrieving a non-existent attribute on a table with a colon does not throw an error." );
- assert.equal( jQuery("#table").attr( "test:attrib", "foobar" ).attr("test:attrib"), "foobar", "Setting an attribute on a table with a colon does not throw an error." );
+ assert.equal( jQuery( "#table" ).attr( "test:attrib" ), undefined, "Retrieving a non-existent attribute on a table with a colon does not throw an error." );
+ assert.equal( jQuery( "#table" ).attr( "test:attrib", "foobar" ).attr( "test:attrib" ), "foobar", "Setting an attribute on a table with a colon does not throw an error." );
- $form = jQuery("
").appendTo("#qunit-fixture");
- assert.equal( $form.attr("class"), "something", "Retrieve the class attribute on a form." );
+ $form = jQuery( "
" ).appendTo( "#qunit-fixture" );
+ assert.equal( $form.attr( "class" ), "something", "Retrieve the class attribute on a form." );
- $a = jQuery("
Click ").appendTo("#qunit-fixture");
- assert.equal( $a.attr("onclick"), "something()", "Retrieve ^on attribute without anonymous function wrapper." );
+ $a = jQuery( "
Click " ).appendTo( "#qunit-fixture" );
+ assert.equal( $a.attr( "onclick" ), "something()", "Retrieve ^on attribute without anonymous function wrapper." );
- assert.ok( jQuery("
").attr("doesntexist") === undefined, "Make sure undefined is returned when no attribute is found." );
- assert.ok( jQuery("
").attr("title") === undefined, "Make sure undefined is returned when no attribute is found." );
- assert.equal( jQuery("
").attr( "title", "something" ).attr("title"), "something", "Set the title attribute." );
- assert.ok( jQuery().attr("doesntexist") === undefined, "Make sure undefined is returned when no element is there." );
- assert.equal( jQuery("
").attr("value"), undefined, "An unset value on a div returns undefined." );
- assert.strictEqual( jQuery("
").attr("value"), undefined, "An unset value on a select returns undefined." );
+ assert.ok( jQuery( "
" ).attr( "doesntexist" ) === undefined, "Make sure undefined is returned when no attribute is found." );
+ assert.ok( jQuery( "
" ).attr( "title" ) === undefined, "Make sure undefined is returned when no attribute is found." );
+ assert.equal( jQuery( "
" ).attr( "title", "something" ).attr( "title" ), "something", "Set the title attribute." );
+ assert.ok( jQuery().attr( "doesntexist" ) === undefined, "Make sure undefined is returned when no element is there." );
+ assert.equal( jQuery( "
" ).attr( "value" ), undefined, "An unset value on a div returns undefined." );
+ assert.strictEqual( jQuery( "
" ).attr( "value" ), undefined, "An unset value on a select returns undefined." );
- $form = jQuery("#form").attr( "enctype", "multipart/form-data" );
- assert.equal( $form.prop("enctype"), "multipart/form-data", "Set the enctype of a form (encoding in IE6/7 #6743)" );
+ $form = jQuery( "#form" ).attr( "enctype", "multipart/form-data" );
+ assert.equal( $form.prop( "enctype" ), "multipart/form-data", "Set the enctype of a form (encoding in IE6/7 #6743)" );
-});
+} );
QUnit.test( "attr(String) on cloned elements, #9646", function( assert ) {
assert.expect( 4 );
var div,
- input = jQuery("
");
+ input = jQuery( "
" );
- input.attr("name");
+ input.attr( "name" );
assert.strictEqual( input.clone( true ).attr( "name", "test" )[ 0 ].name, "test", "Name attribute should be changed on cloned element" );
- div = jQuery("
");
- div.attr("id");
+ div = jQuery( "
" );
+ div.attr( "id" );
assert.strictEqual( div.clone( true ).attr( "id", "test" )[ 0 ].id, "test", "Id attribute should be changed on cloned element" );
- input = jQuery("
");
- input.attr("value");
+ input = jQuery( "
" );
+ input.attr( "value" );
assert.strictEqual( input.clone( true ).attr( "value", "test" )[ 0 ].value, "test", "Value attribute should be changed on cloned element" );
assert.strictEqual( input.clone( true ).attr( "value", 42 )[ 0 ].value, "42", "Value attribute should be changed on cloned element" );
-});
+} );
QUnit.test( "attr(String) in XML Files", function( assert ) {
assert.expect( 3 );
var xml = createDashboardXML();
- assert.equal( jQuery( "locations", xml ).attr("class"), "foo", "Check class attribute in XML document" );
- assert.equal( jQuery( "location", xml ).attr("for"), "bar", "Check for attribute in XML document" );
- assert.equal( jQuery( "location", xml ).attr("checked"), "different", "Check that hooks are not attached in XML document" );
-});
+ assert.equal( jQuery( "locations", xml ).attr( "class" ), "foo", "Check class attribute in XML document" );
+ assert.equal( jQuery( "location", xml ).attr( "for" ), "bar", "Check for attribute in XML document" );
+ assert.equal( jQuery( "location", xml ).attr( "checked" ), "different", "Check that hooks are not attached in XML document" );
+} );
QUnit.test( "attr(String, Function)", function( assert ) {
assert.expect( 2 );
assert.equal(
- jQuery("#text1").attr( "value", function() {
+ jQuery( "#text1" ).attr( "value", function() {
return this.id;
- }).attr("value"),
+ } ).attr( "value" ),
"text1",
"Set value from id"
);
assert.equal(
- jQuery("#text1").attr( "title", function(i) {
+ jQuery( "#text1" ).attr( "title", function( i ) {
return i;
- }).attr("title"),
+ } ).attr( "title" ),
"0",
"Set value with an index"
);
-});
+} );
QUnit.test( "attr(Hash)", function( assert ) {
assert.expect( 3 );
var pass = true;
- jQuery("div").attr({
+ jQuery( "div" ).attr( {
"foo": "baz",
"zoo": "ping"
- }).each(function() {
- if ( this.getAttribute("foo") !== "baz" && this.getAttribute("zoo") !== "ping" ) {
+ } ).each( function() {
+ if ( this.getAttribute( "foo" ) !== "baz" && this.getAttribute( "zoo" ) !== "ping" ) {
pass = false;
}
- });
+ } );
assert.ok( pass, "Set Multiple Attributes" );
assert.equal(
- jQuery("#text1").attr({
+ jQuery( "#text1" ).attr( {
"value": function() {
- return this["id"];
- }}).attr("value"),
+ return this[ "id" ];
+ } } ).attr( "value" ),
"text1",
"Set attribute to computed value #1"
);
assert.equal(
- jQuery("#text1").attr({
- "title": function(i) {
+ jQuery( "#text1" ).attr( {
+ "title": function( i ) {
return i;
}
- }).attr("title"),
+ } ).attr( "title" ),
"0",
"Set attribute to computed value #2"
);
-});
+} );
QUnit.test( "attr(String, Object)", function( assert ) {
assert.expect( 71 );
@@ -257,12 +258,12 @@ QUnit.test( "attr(String, Object)", function( assert ) {
attributeNode, commentNode, textNode, obj,
table, td, j, type,
check, thrown, button, $radio, $radios, $svg,
- div = jQuery("div").attr("foo", "bar"),
+ div = jQuery( "div" ).attr( "foo", "bar" ),
i = 0,
fail = false;
for ( ; i < div.length; i++ ) {
- if ( div[ i ].getAttribute("foo") !== "bar" ) {
+ if ( div[ i ].getAttribute( "foo" ) !== "bar" ) {
fail = i;
break;
}
@@ -271,187 +272,187 @@ QUnit.test( "attr(String, Object)", function( assert ) {
assert.equal( fail, false, "Set Attribute, the #" + fail + " element didn't get the attribute 'foo'" );
assert.ok(
- jQuery("#foo").attr({
+ jQuery( "#foo" ).attr( {
"width": null
- }),
+ } ),
"Try to set an attribute to nothing"
);
- jQuery("#name").attr( "name", "something" );
- assert.equal( jQuery("#name").attr("name"), "something", "Set name attribute" );
- jQuery("#name").attr( "name", null );
- assert.equal( jQuery("#name").attr("name"), undefined, "Remove name attribute" );
+ jQuery( "#name" ).attr( "name", "something" );
+ assert.equal( jQuery( "#name" ).attr( "name" ), "something", "Set name attribute" );
+ jQuery( "#name" ).attr( "name", null );
+ assert.equal( jQuery( "#name" ).attr( "name" ), undefined, "Remove name attribute" );
$input = jQuery( "
", {
name: "something",
id: "specified"
- });
- assert.equal( $input.attr("name"), "something", "Check element creation gets/sets the name attribute." );
- assert.equal( $input.attr("id"), "specified", "Check element creation gets/sets the id attribute." );
+ } );
+ assert.equal( $input.attr( "name" ), "something", "Check element creation gets/sets the name attribute." );
+ assert.equal( $input.attr( "id" ), "specified", "Check element creation gets/sets the id attribute." );
// As of fixing #11115, we only guarantee boolean property update for checked and selected
- $input = jQuery("
").attr( "checked", true );
- assert.equal( $input.prop("checked"), true, "Setting checked updates property (verified by .prop)" );
- assert.equal( $input[0].checked, true, "Setting checked updates property (verified by native property)" );
- $input = jQuery("
").attr( "selected", true );
- assert.equal( $input.prop("selected"), true, "Setting selected updates property (verified by .prop)" );
- assert.equal( $input[0].selected, true, "Setting selected updates property (verified by native property)" );
+ $input = jQuery( "
" ).attr( "checked", true );
+ assert.equal( $input.prop( "checked" ), true, "Setting checked updates property (verified by .prop)" );
+ assert.equal( $input[ 0 ].checked, true, "Setting checked updates property (verified by native property)" );
+ $input = jQuery( "
" ).attr( "selected", true );
+ assert.equal( $input.prop( "selected" ), true, "Setting selected updates property (verified by .prop)" );
+ assert.equal( $input[ 0 ].selected, true, "Setting selected updates property (verified by native property)" );
- $input = jQuery("#check2");
+ $input = jQuery( "#check2" );
$input.prop( "checked", true ).prop( "checked", false ).attr( "checked", true );
- assert.equal( $input.attr("checked"), "checked", "Set checked (verified by .attr)" );
+ assert.equal( $input.attr( "checked" ), "checked", "Set checked (verified by .attr)" );
$input.prop( "checked", false ).prop( "checked", true ).attr( "checked", false );
- assert.equal( $input.attr("checked"), undefined, "Remove checked (verified by .attr)" );
+ assert.equal( $input.attr( "checked" ), undefined, "Remove checked (verified by .attr)" );
- $input = jQuery("#text1").prop( "readOnly", true ).prop( "readOnly", false ).attr( "readonly", true );
- assert.equal( $input.attr("readonly"), "readonly", "Set readonly (verified by .attr)" );
+ $input = jQuery( "#text1" ).prop( "readOnly", true ).prop( "readOnly", false ).attr( "readonly", true );
+ assert.equal( $input.attr( "readonly" ), "readonly", "Set readonly (verified by .attr)" );
$input.prop( "readOnly", false ).prop( "readOnly", true ).attr( "readonly", false );
- assert.equal( $input.attr("readonly"), undefined, "Remove readonly (verified by .attr)" );
+ assert.equal( $input.attr( "readonly" ), undefined, "Remove readonly (verified by .attr)" );
- $input = jQuery("#check2").attr( "checked", true ).attr( "checked", false ).prop( "checked", true );
- assert.equal( $input[0].checked, true, "Set checked property (verified by native property)" );
- assert.equal( $input.prop("checked"), true, "Set checked property (verified by .prop)" );
- assert.equal( $input.attr("checked"), undefined, "Setting checked property doesn't affect checked attribute" );
+ $input = jQuery( "#check2" ).attr( "checked", true ).attr( "checked", false ).prop( "checked", true );
+ assert.equal( $input[ 0 ].checked, true, "Set checked property (verified by native property)" );
+ assert.equal( $input.prop( "checked" ), true, "Set checked property (verified by .prop)" );
+ assert.equal( $input.attr( "checked" ), undefined, "Setting checked property doesn't affect checked attribute" );
$input.attr( "checked", false ).attr( "checked", true ).prop( "checked", false );
- assert.equal( $input[0].checked, false, "Clear checked property (verified by native property)" );
- assert.equal( $input.prop("checked"), false, "Clear checked property (verified by .prop)" );
- assert.equal( $input.attr("checked"), "checked", "Clearing checked property doesn't affect checked attribute" );
+ assert.equal( $input[ 0 ].checked, false, "Clear checked property (verified by native property)" );
+ assert.equal( $input.prop( "checked" ), false, "Clear checked property (verified by .prop)" );
+ assert.equal( $input.attr( "checked" ), "checked", "Clearing checked property doesn't affect checked attribute" );
- $input = jQuery("#check2").attr( "checked", false ).attr( "checked", "checked" );
- assert.equal( $input.attr("checked"), "checked", "Set checked to 'checked' (verified by .attr)" );
+ $input = jQuery( "#check2" ).attr( "checked", false ).attr( "checked", "checked" );
+ assert.equal( $input.attr( "checked" ), "checked", "Set checked to 'checked' (verified by .attr)" );
- $radios = jQuery("#checkedtest").find("input[type='radio']");
- $radios.eq( 1 ).trigger("click");
- assert.equal( $radios.eq( 1 ).prop("checked"), true, "Second radio was checked when clicked" );
- assert.equal( $radios.eq( 0 ).attr("checked"), "checked", "First radio is still [checked]" );
+ $radios = jQuery( "#checkedtest" ).find( "input[type='radio']" );
+ $radios.eq( 1 ).trigger( "click" );
+ assert.equal( $radios.eq( 1 ).prop( "checked" ), true, "Second radio was checked when clicked" );
+ assert.equal( $radios.eq( 0 ).attr( "checked" ), "checked", "First radio is still [checked]" );
- $input = jQuery("#text1").attr( "readonly", false ).prop( "readOnly", true );
- assert.equal( $input[0].readOnly, true, "Set readonly property (verified by native property)" );
- assert.equal( $input.prop("readOnly"), true, "Set readonly property (verified by .prop)" );
+ $input = jQuery( "#text1" ).attr( "readonly", false ).prop( "readOnly", true );
+ assert.equal( $input[ 0 ].readOnly, true, "Set readonly property (verified by native property)" );
+ assert.equal( $input.prop( "readOnly" ), true, "Set readonly property (verified by .prop)" );
$input.attr( "readonly", true ).prop( "readOnly", false );
- assert.equal( $input[0].readOnly, false, "Clear readonly property (verified by native property)" );
- assert.equal( $input.prop("readOnly"), false, "Clear readonly property (verified by .prop)" );
+ assert.equal( $input[ 0 ].readOnly, false, "Clear readonly property (verified by native property)" );
+ assert.equal( $input.prop( "readOnly" ), false, "Clear readonly property (verified by .prop)" );
- $input = jQuery("#name").attr( "maxlength", "5" );
- assert.equal( $input[0].maxLength, 5, "Set maxlength (verified by native property)" );
+ $input = jQuery( "#name" ).attr( "maxlength", "5" );
+ assert.equal( $input[ 0 ].maxLength, 5, "Set maxlength (verified by native property)" );
$input.attr( "maxLength", "10" );
- assert.equal( $input[0].maxLength, 10, "Set maxlength (verified by native property)" );
+ assert.equal( $input[ 0 ].maxLength, 10, "Set maxlength (verified by native property)" );
// HTML5 boolean attributes
- $text = jQuery("#text1").attr({
+ $text = jQuery( "#text1" ).attr( {
"autofocus": true,
"required": true
- });
- assert.equal( $text.attr("autofocus"), "autofocus", "Reading autofocus attribute yields 'autofocus'" );
- assert.equal( $text.attr( "autofocus", false ).attr("autofocus"), undefined, "Setting autofocus to false removes it" );
- assert.equal( $text.attr("required"), "required", "Reading required attribute yields 'required'" );
- assert.equal( $text.attr( "required", false ).attr("required"), undefined, "Setting required attribute to false removes it" );
+ } );
+ assert.equal( $text.attr( "autofocus" ), "autofocus", "Reading autofocus attribute yields 'autofocus'" );
+ assert.equal( $text.attr( "autofocus", false ).attr( "autofocus" ), undefined, "Setting autofocus to false removes it" );
+ assert.equal( $text.attr( "required" ), "required", "Reading required attribute yields 'required'" );
+ assert.equal( $text.attr( "required", false ).attr( "required" ), undefined, "Setting required attribute to false removes it" );
- $details = jQuery("
").appendTo("#qunit-fixture");
- assert.equal( $details.attr("open"), "open", "open attribute presence indicates true" );
- assert.equal( $details.attr( "open", false ).attr("open"), undefined, "Setting open attribute to false removes it" );
+ $details = jQuery( "
" ).appendTo( "#qunit-fixture" );
+ assert.equal( $details.attr( "open" ), "open", "open attribute presence indicates true" );
+ assert.equal( $details.attr( "open", false ).attr( "open" ), undefined, "Setting open attribute to false removes it" );
$text.attr( "data-something", true );
- assert.equal( $text.attr("data-something"), "true", "Set data attributes");
- assert.equal( $text.data("something"), true, "Setting data attributes are not affected by boolean settings");
+ assert.equal( $text.attr( "data-something" ), "true", "Set data attributes" );
+ assert.equal( $text.data( "something" ), true, "Setting data attributes are not affected by boolean settings" );
$text.attr( "data-another", false );
- assert.equal( $text.attr("data-another"), "false", "Set data attributes");
- assert.equal( $text.data("another"), false, "Setting data attributes are not affected by boolean settings" );
- assert.equal( $text.attr( "aria-disabled", false ).attr("aria-disabled"), "false", "Setting aria attributes are not affected by boolean settings" );
- $text.removeData("something").removeData("another").removeAttr("aria-disabled");
+ assert.equal( $text.attr( "data-another" ), "false", "Set data attributes" );
+ assert.equal( $text.data( "another" ), false, "Setting data attributes are not affected by boolean settings" );
+ assert.equal( $text.attr( "aria-disabled", false ).attr( "aria-disabled" ), "false", "Setting aria attributes are not affected by boolean settings" );
+ $text.removeData( "something" ).removeData( "another" ).removeAttr( "aria-disabled" );
- jQuery("#foo").attr("contenteditable", true);
- assert.equal( jQuery("#foo").attr("contenteditable"), "true", "Enumerated attributes are set properly" );
+ jQuery( "#foo" ).attr( "contenteditable", true );
+ assert.equal( jQuery( "#foo" ).attr( "contenteditable" ), "true", "Enumerated attributes are set properly" );
- attributeNode = document.createAttribute("irrelevant");
- commentNode = document.createComment("some comment");
- textNode = document.createTextNode("some text");
+ attributeNode = document.createAttribute( "irrelevant" );
+ commentNode = document.createComment( "some comment" );
+ textNode = document.createTextNode( "some text" );
obj = {};
jQuery.each( [ commentNode, textNode, attributeNode ], function( i, elem ) {
var $elem = jQuery( elem );
$elem.attr( "nonexisting", "foo" );
- assert.strictEqual( $elem.attr("nonexisting"), undefined, "attr(name, value) works correctly on comment and text nodes (bug #7500)." );
- });
+ assert.strictEqual( $elem.attr( "nonexisting" ), undefined, "attr(name, value) works correctly on comment and text nodes (bug #7500)." );
+ } );
jQuery.each( [ window, document, obj, "#firstp" ], function( i, elem ) {
var oldVal = elem.nonexisting,
$elem = jQuery( elem );
- assert.strictEqual( $elem.attr("nonexisting"), undefined, "attr works correctly for non existing attributes (bug #7500)." );
- assert.equal( $elem.attr( "nonexisting", "foo" ).attr("nonexisting"), "foo", "attr falls back to prop on unsupported arguments" );
+ assert.strictEqual( $elem.attr( "nonexisting" ), undefined, "attr works correctly for non existing attributes (bug #7500)." );
+ assert.equal( $elem.attr( "nonexisting", "foo" ).attr( "nonexisting" ), "foo", "attr falls back to prop on unsupported arguments" );
elem.nonexisting = oldVal;
- });
+ } );
// Register the property on the window for the previous assertion so it will be clean up
Globals.register( "nonexisting" );
- table = jQuery("#table").append("
cell cell cell cell cell ");
- td = table.find("td").eq(0);
+ table = jQuery( "#table" ).append( "
cell cell cell cell cell " );
+ td = table.find( "td" ).eq( 0 );
td.attr( "rowspan", "2" );
- assert.equal( td[ 0 ]["rowSpan"], 2, "Check rowspan is correctly set" );
+ assert.equal( td[ 0 ][ "rowSpan" ], 2, "Check rowspan is correctly set" );
td.attr( "colspan", "2" );
- assert.equal( td[ 0 ]["colSpan"], 2, "Check colspan is correctly set" );
- table.attr("cellspacing", "2");
- assert.equal( table[ 0 ]["cellSpacing"], "2", "Check cellspacing is correctly set" );
+ assert.equal( td[ 0 ][ "colSpan" ], 2, "Check colspan is correctly set" );
+ table.attr( "cellspacing", "2" );
+ assert.equal( table[ 0 ][ "cellSpacing" ], "2", "Check cellspacing is correctly set" );
- assert.equal( jQuery("#area1").attr("value"), undefined, "Value attribute is distinct from value property." );
+ assert.equal( jQuery( "#area1" ).attr( "value" ), undefined, "Value attribute is distinct from value property." );
// for #1070
- jQuery("#name").attr( "someAttr", "0" );
- assert.equal( jQuery("#name").attr("someAttr"), "0", "Set attribute to a string of '0'" );
- jQuery("#name").attr( "someAttr", 0 );
- assert.equal( jQuery("#name").attr("someAttr"), "0", "Set attribute to the number 0" );
- jQuery("#name").attr( "someAttr", 1 );
- assert.equal( jQuery("#name").attr("someAttr"), "1", "Set attribute to the number 1" );
+ jQuery( "#name" ).attr( "someAttr", "0" );
+ assert.equal( jQuery( "#name" ).attr( "someAttr" ), "0", "Set attribute to a string of '0'" );
+ jQuery( "#name" ).attr( "someAttr", 0 );
+ assert.equal( jQuery( "#name" ).attr( "someAttr" ), "0", "Set attribute to the number 0" );
+ jQuery( "#name" ).attr( "someAttr", 1 );
+ assert.equal( jQuery( "#name" ).attr( "someAttr" ), "1", "Set attribute to the number 1" );
// using contents will get comments regular, text, and comment nodes
- j = jQuery("#nonnodes").contents();
+ j = jQuery( "#nonnodes" ).contents();
j.attr( "name", "attrvalue" );
- assert.equal( j.attr("name"), "attrvalue", "Check node,textnode,comment for attr" );
- j.removeAttr("name");
+ assert.equal( j.attr( "name" ), "attrvalue", "Check node,textnode,comment for attr" );
+ j.removeAttr( "name" );
// Type
- type = jQuery("#check2").attr("type");
+ type = jQuery( "#check2" ).attr( "type" );
try {
- jQuery("#check2").attr( "type", "hidden" );
+ jQuery( "#check2" ).attr( "type", "hidden" );
assert.ok( true, "No exception thrown on input type change" );
- } catch( e ) {
+ } catch ( e ) {
assert.ok( true, "Exception thrown on input type change: " + e );
}
- check = document.createElement("input");
+ check = document.createElement( "input" );
thrown = true;
try {
jQuery( check ).attr( "type", "checkbox" );
- } catch( e ) {
+ } catch ( e ) {
thrown = false;
}
assert.ok( thrown, "Exception thrown when trying to change type property" );
- assert.equal( "checkbox", jQuery( check ).attr("type"), "Verify that you can change the type of an input element that isn't in the DOM" );
+ assert.equal( "checkbox", jQuery( check ).attr( "type" ), "Verify that you can change the type of an input element that isn't in the DOM" );
- check = jQuery("
");
+ check = jQuery( "
" );
thrown = true;
try {
check.attr( "type", "checkbox" );
- } catch( e ) {
+ } catch ( e ) {
thrown = false;
}
assert.ok( thrown, "Exception thrown when trying to change type property" );
- assert.equal( "checkbox", check.attr("type"), "Verify that you can change the type of an input element that isn't in the DOM" );
+ assert.equal( "checkbox", check.attr( "type" ), "Verify that you can change the type of an input element that isn't in the DOM" );
- button = jQuery("#button");
+ button = jQuery( "#button" );
try {
button.attr( "type", "submit" );
assert.ok( true, "No exception thrown on button type change" );
- } catch( e ) {
+ } catch ( e ) {
assert.ok( true, "Exception thrown on button type change: " + e );
}
$radio = jQuery( "
", {
"value": "sup",
"type": "radio"
- }).appendTo("#testForm");
+ } ).appendTo( "#testForm" );
assert.equal( $radio.val(), "sup", "Value is not reset when type is set after value on a radio" );
// Setting attributes on svg elements (bug #3116)
@@ -460,16 +461,16 @@ QUnit.test( "attr(String, Object)", function( assert ) {
"
" +
""
- ).appendTo("body");
- assert.equal( $svg.attr( "cx", 100 ).attr("cx"), "100", "Set attribute on svg element" );
+ ).appendTo( "body" );
+ assert.equal( $svg.attr( "cx", 100 ).attr( "cx" ), "100", "Set attribute on svg element" );
$svg.remove();
// undefined values are chainable
- jQuery("#name").attr( "maxlength", "5" ).removeAttr("nonexisting");
- assert.equal( typeof jQuery("#name").attr( "maxlength", undefined ), "object", ".attr('attribute', undefined) is chainable (#5571)" );
- assert.equal( jQuery("#name").attr( "maxlength", undefined ).attr("maxlength"), "5", ".attr('attribute', undefined) does not change value (#5571)" );
- assert.equal( jQuery("#name").attr( "nonexisting", undefined ).attr("nonexisting"), undefined, ".attr('attribute', undefined) does not create attribute (#5571)" );
-});
+ jQuery( "#name" ).attr( "maxlength", "5" ).removeAttr( "nonexisting" );
+ assert.equal( typeof jQuery( "#name" ).attr( "maxlength", undefined ), "object", ".attr('attribute', undefined) is chainable (#5571)" );
+ assert.equal( jQuery( "#name" ).attr( "maxlength", undefined ).attr( "maxlength" ), "5", ".attr('attribute', undefined) does not change value (#5571)" );
+ assert.equal( jQuery( "#name" ).attr( "nonexisting", undefined ).attr( "nonexisting" ), undefined, ".attr('attribute', undefined) does not create attribute (#5571)" );
+} );
QUnit.test( "attr - extending the boolean attrHandle", function( assert ) {
assert.expect( 1 );
@@ -483,18 +484,18 @@ QUnit.test( "attr - extending the boolean attrHandle", function( assert ) {
called = false;
jQuery( "input" ).attr( "checked" );
assert.ok( called, "The boolean attrHandle does not drop custom attrHandles" );
-});
+} );
QUnit.test( "attr(String, Object) - Loaded via XML document", function( assert ) {
assert.expect( 2 );
var xml = createDashboardXML(),
titles = [];
- jQuery( "tab", xml ).each(function() {
- titles.push( jQuery( this ).attr("title") );
- });
+ jQuery( "tab", xml ).each( function() {
+ titles.push( jQuery( this ).attr( "title" ) );
+ } );
assert.equal( titles[ 0 ], "Location", "attr() in XML context: Check first title" );
assert.equal( titles[ 1 ], "Users", "attr() in XML context: Check second title" );
-});
+} );
QUnit.test( "attr(String, Object) - Loaded via XML fragment", function( assert ) {
assert.expect( 2 );
@@ -502,121 +503,121 @@ QUnit.test( "attr(String, Object) - Loaded via XML fragment", function( assert )
$frag = jQuery( frag );
$frag.attr( "test", "some value" );
- assert.equal( $frag.attr("test"), "some value", "set attribute" );
+ assert.equal( $frag.attr( "test" ), "some value", "set attribute" );
$frag.attr( "test", null );
- assert.equal( $frag.attr("test"), undefined, "remove attribute" );
-});
+ assert.equal( $frag.attr( "test" ), undefined, "remove attribute" );
+} );
QUnit.test( "attr('tabindex')", function( assert ) {
assert.expect( 8 );
// elements not natively tabbable
- assert.equal( jQuery("#listWithTabIndex").attr("tabindex"), "5", "not natively tabbable, with tabindex set to 0" );
- assert.equal( jQuery("#divWithNoTabIndex").attr("tabindex"), undefined, "not natively tabbable, no tabindex set" );
+ assert.equal( jQuery( "#listWithTabIndex" ).attr( "tabindex" ), "5", "not natively tabbable, with tabindex set to 0" );
+ assert.equal( jQuery( "#divWithNoTabIndex" ).attr( "tabindex" ), undefined, "not natively tabbable, no tabindex set" );
// anchor with href
- assert.equal( jQuery("#linkWithNoTabIndex").attr("tabindex"), undefined, "anchor with href, no tabindex set" );
- assert.equal( jQuery("#linkWithTabIndex").attr("tabindex"), "2", "anchor with href, tabindex set to 2" );
- assert.equal( jQuery("#linkWithNegativeTabIndex").attr("tabindex"), "-1", "anchor with href, tabindex set to -1" );
+ assert.equal( jQuery( "#linkWithNoTabIndex" ).attr( "tabindex" ), undefined, "anchor with href, no tabindex set" );
+ assert.equal( jQuery( "#linkWithTabIndex" ).attr( "tabindex" ), "2", "anchor with href, tabindex set to 2" );
+ assert.equal( jQuery( "#linkWithNegativeTabIndex" ).attr( "tabindex" ), "-1", "anchor with href, tabindex set to -1" );
// anchor without href
- assert.equal( jQuery("#linkWithNoHrefWithNoTabIndex").attr("tabindex"), undefined, "anchor without href, no tabindex set" );
- assert.equal( jQuery("#linkWithNoHrefWithTabIndex").attr("tabindex"), "1", "anchor without href, tabindex set to 2" );
- assert.equal( jQuery("#linkWithNoHrefWithNegativeTabIndex").attr("tabindex"), "-1", "anchor without href, no tabindex set" );
-});
+ assert.equal( jQuery( "#linkWithNoHrefWithNoTabIndex" ).attr( "tabindex" ), undefined, "anchor without href, no tabindex set" );
+ assert.equal( jQuery( "#linkWithNoHrefWithTabIndex" ).attr( "tabindex" ), "1", "anchor without href, tabindex set to 2" );
+ assert.equal( jQuery( "#linkWithNoHrefWithNegativeTabIndex" ).attr( "tabindex" ), "-1", "anchor without href, no tabindex set" );
+} );
QUnit.test( "attr('tabindex', value)", function( assert ) {
assert.expect( 9 );
- var element = jQuery("#divWithNoTabIndex");
- assert.equal( element.attr("tabindex"), undefined, "start with no tabindex" );
+ var element = jQuery( "#divWithNoTabIndex" );
+ assert.equal( element.attr( "tabindex" ), undefined, "start with no tabindex" );
// set a positive string
element.attr( "tabindex", "1" );
- assert.equal( element.attr("tabindex"), "1", "set tabindex to 1 (string)" );
+ assert.equal( element.attr( "tabindex" ), "1", "set tabindex to 1 (string)" );
// set a zero string
element.attr( "tabindex", "0" );
- assert.equal( element.attr("tabindex"), "0", "set tabindex to 0 (string)" );
+ assert.equal( element.attr( "tabindex" ), "0", "set tabindex to 0 (string)" );
// set a negative string
element.attr( "tabindex", "-1" );
- assert.equal( element.attr("tabindex"), "-1", "set tabindex to -1 (string)" );
+ assert.equal( element.attr( "tabindex" ), "-1", "set tabindex to -1 (string)" );
// set a positive number
element.attr( "tabindex", 1 );
- assert.equal( element.attr("tabindex"), "1", "set tabindex to 1 (number)" );
+ assert.equal( element.attr( "tabindex" ), "1", "set tabindex to 1 (number)" );
// set a zero number
element.attr( "tabindex", 0 );
- assert.equal(element.attr("tabindex"), "0", "set tabindex to 0 (number)");
+ assert.equal( element.attr( "tabindex" ), "0", "set tabindex to 0 (number)" );
// set a negative number
element.attr( "tabindex", -1 );
- assert.equal( element.attr("tabindex"), "-1", "set tabindex to -1 (number)" );
+ assert.equal( element.attr( "tabindex" ), "-1", "set tabindex to -1 (number)" );
- element = jQuery("#linkWithTabIndex");
- assert.equal( element.attr("tabindex"), "2", "start with tabindex 2" );
+ element = jQuery( "#linkWithTabIndex" );
+ assert.equal( element.attr( "tabindex" ), "2", "start with tabindex 2" );
element.attr( "tabindex", -1 );
- assert.equal( element.attr("tabindex"), "-1", "set negative tabindex" );
-});
+ assert.equal( element.attr( "tabindex" ), "-1", "set negative tabindex" );
+} );
QUnit.test( "removeAttr(String)", function( assert ) {
assert.expect( 12 );
var $first;
- assert.equal( jQuery("#mark").removeAttr("class").attr("class"), undefined, "remove class" );
- assert.equal( jQuery("#form").removeAttr("id").attr("id"), undefined, "Remove id" );
- assert.equal( jQuery("#foo").attr( "style", "position:absolute;" ).removeAttr("style").attr("style"), undefined, "Check removing style attribute" );
- assert.equal( jQuery("#form").attr( "style", "position:absolute;" ).removeAttr("style").attr("style"), undefined, "Check removing style attribute on a form" );
- assert.equal( jQuery("
").appendTo("#foo").removeAttr("style").prop("style").cssText, "", "Check removing style attribute (#9699 Webkit)" );
- assert.equal( jQuery("#fx-test-group").attr( "height", "3px" ).removeAttr("height").get( 0 ).style.height, "1px", "Removing height attribute has no effect on height set with style attribute" );
+ assert.equal( jQuery( "#mark" ).removeAttr( "class" ).attr( "class" ), undefined, "remove class" );
+ assert.equal( jQuery( "#form" ).removeAttr( "id" ).attr( "id" ), undefined, "Remove id" );
+ assert.equal( jQuery( "#foo" ).attr( "style", "position:absolute;" ).removeAttr( "style" ).attr( "style" ), undefined, "Check removing style attribute" );
+ assert.equal( jQuery( "#form" ).attr( "style", "position:absolute;" ).removeAttr( "style" ).attr( "style" ), undefined, "Check removing style attribute on a form" );
+ assert.equal( jQuery( "
" ).appendTo( "#foo" ).removeAttr( "style" ).prop( "style" ).cssText, "", "Check removing style attribute (#9699 Webkit)" );
+ assert.equal( jQuery( "#fx-test-group" ).attr( "height", "3px" ).removeAttr( "height" ).get( 0 ).style.height, "1px", "Removing height attribute has no effect on height set with style attribute" );
- jQuery("#check1").removeAttr("checked").prop( "checked", true ).removeAttr("checked");
- assert.equal( document.getElementById("check1").checked, false, "removeAttr sets boolean properties to false" );
- jQuery("#text1").prop( "readOnly", true ).removeAttr("readonly");
- assert.equal( document.getElementById("text1").readOnly, false, "removeAttr sets boolean properties to false" );
+ jQuery( "#check1" ).removeAttr( "checked" ).prop( "checked", true ).removeAttr( "checked" );
+ assert.equal( document.getElementById( "check1" ).checked, false, "removeAttr sets boolean properties to false" );
+ jQuery( "#text1" ).prop( "readOnly", true ).removeAttr( "readonly" );
+ assert.equal( document.getElementById( "text1" ).readOnly, false, "removeAttr sets boolean properties to false" );
- jQuery("#option2c").removeAttr("selected");
- assert.equal( jQuery("#option2d").attr("selected"), "selected", "Removing `selected` from an option that is not selected does not remove selected from the currently selected option (#10870)" );
+ jQuery( "#option2c" ).removeAttr( "selected" );
+ assert.equal( jQuery( "#option2d" ).attr( "selected" ), "selected", "Removing `selected` from an option that is not selected does not remove selected from the currently selected option (#10870)" );
try {
- $first = jQuery("#first").attr( "contenteditable", "true" ).removeAttr("contenteditable");
- assert.equal( $first.attr("contenteditable"), undefined, "Remove the contenteditable attribute" );
- } catch( e ) {
+ $first = jQuery( "#first" ).attr( "contenteditable", "true" ).removeAttr( "contenteditable" );
+ assert.equal( $first.attr( "contenteditable" ), undefined, "Remove the contenteditable attribute" );
+ } catch ( e ) {
assert.ok( false, "Removing contenteditable threw an error (#10429)" );
}
- $first = jQuery("
");
- assert.equal( $first.attr("Case"), "mixed", "case of attribute doesn't matter" );
- $first.removeAttr("Case");
+ $first = jQuery( "
" );
+ assert.equal( $first.attr( "Case" ), "mixed", "case of attribute doesn't matter" );
+ $first.removeAttr( "Case" );
assert.equal( $first.attr( "Case" ), undefined, "mixed-case attribute was removed" );
-});
+} );
QUnit.test( "removeAttr(String) in XML", function( assert ) {
assert.expect( 7 );
var xml = createDashboardXML(),
iwt = jQuery( "infowindowtab", xml );
- assert.equal( iwt.attr("normal"), "ab", "Check initial value" );
- iwt.removeAttr("Normal");
- assert.equal( iwt.attr("normal"), "ab", "Should still be there" );
- iwt.removeAttr("normal");
- assert.equal( iwt.attr("normal"), undefined, "Removed" );
+ assert.equal( iwt.attr( "normal" ), "ab", "Check initial value" );
+ iwt.removeAttr( "Normal" );
+ assert.equal( iwt.attr( "normal" ), "ab", "Should still be there" );
+ iwt.removeAttr( "normal" );
+ assert.equal( iwt.attr( "normal" ), undefined, "Removed" );
- assert.equal( iwt.attr("mixedCase"), "yes", "Check initial value" );
- assert.equal( iwt.attr("mixedcase"), undefined, "toLowerCase not work good" );
- iwt.removeAttr("mixedcase");
- assert.equal( iwt.attr("mixedCase"), "yes", "Should still be there" );
- iwt.removeAttr("mixedCase");
- assert.equal( iwt.attr("mixedCase"), undefined, "Removed" );
-});
+ assert.equal( iwt.attr( "mixedCase" ), "yes", "Check initial value" );
+ assert.equal( iwt.attr( "mixedcase" ), undefined, "toLowerCase not work good" );
+ iwt.removeAttr( "mixedcase" );
+ assert.equal( iwt.attr( "mixedCase" ), "yes", "Should still be there" );
+ iwt.removeAttr( "mixedCase" );
+ assert.equal( iwt.attr( "mixedCase" ), undefined, "Removed" );
+} );
QUnit.test( "removeAttr(Multi String, variable space width)", function( assert ) {
assert.expect( 8 );
- var div = jQuery("
"),
+ var div = jQuery( "
" ),
tests = {
id: "a",
alt: "b",
@@ -626,46 +627,46 @@ QUnit.test( "removeAttr(Multi String, variable space width)", function( assert )
jQuery.each( tests, function( key, val ) {
assert.equal( div.attr( key ), val, "Attribute `" + key + "` exists, and has a value of `" + val + "`" );
- });
+ } );
div.removeAttr( "id alt title rel " );
jQuery.each( tests, function( key ) {
assert.equal( div.attr( key ), undefined, "Attribute `" + key + "` was removed" );
- });
-});
+ } );
+} );
QUnit.test( "prop(String, Object)", function( assert ) {
assert.expect( 17 );
- assert.equal( jQuery("#text1").prop("value"), "Test", "Check for value attribute" );
- assert.equal( jQuery("#text1").prop( "value", "Test2" ).prop("defaultValue"), "Test", "Check for defaultValue attribute" );
- assert.equal( jQuery("#select2").prop("selectedIndex"), 3, "Check for selectedIndex attribute" );
- assert.equal( jQuery("#foo").prop("nodeName").toUpperCase(), "DIV", "Check for nodeName attribute" );
- assert.equal( jQuery("#foo").prop("tagName").toUpperCase(), "DIV", "Check for tagName attribute" );
- assert.equal( jQuery("
").prop("selected"), false, "Check selected attribute on disconnected element." );
+ assert.equal( jQuery( "#text1" ).prop( "value" ), "Test", "Check for value attribute" );
+ assert.equal( jQuery( "#text1" ).prop( "value", "Test2" ).prop( "defaultValue" ), "Test", "Check for defaultValue attribute" );
+ assert.equal( jQuery( "#select2" ).prop( "selectedIndex" ), 3, "Check for selectedIndex attribute" );
+ assert.equal( jQuery( "#foo" ).prop( "nodeName" ).toUpperCase(), "DIV", "Check for nodeName attribute" );
+ assert.equal( jQuery( "#foo" ).prop( "tagName" ).toUpperCase(), "DIV", "Check for tagName attribute" );
+ assert.equal( jQuery( "
" ).prop( "selected" ), false, "Check selected attribute on disconnected element." );
- assert.equal( jQuery("#listWithTabIndex").prop("tabindex"), 5, "Check retrieving tabindex" );
- jQuery("#text1").prop( "readonly", true );
- assert.equal( document.getElementById("text1").readOnly, true, "Check setting readOnly property with 'readonly'" );
- assert.equal( jQuery("#label-for").prop("for"), "action", "Check retrieving htmlFor" );
- jQuery("#text1").prop("class", "test");
- assert.equal( document.getElementById("text1").className, "test", "Check setting className with 'class'" );
- assert.equal( jQuery("#text1").prop("maxlength"), 30, "Check retrieving maxLength" );
- jQuery("#table").prop( "cellspacing", 1 );
- assert.equal( jQuery("#table").prop("cellSpacing"), "1", "Check setting and retrieving cellSpacing" );
- jQuery("#table").prop( "cellpadding", 1 );
- assert.equal( jQuery("#table").prop("cellPadding"), "1", "Check setting and retrieving cellPadding" );
- jQuery("#table").prop( "rowspan", 1 );
- assert.equal( jQuery("#table").prop("rowSpan"), 1, "Check setting and retrieving rowSpan" );
- jQuery("#table").prop( "colspan", 1 );
- assert.equal( jQuery("#table").prop("colSpan"), 1, "Check setting and retrieving colSpan" );
- jQuery("#table").prop( "usemap", 1 );
- assert.equal( jQuery("#table").prop("useMap"), 1, "Check setting and retrieving useMap" );
- jQuery("#table").prop( "frameborder", 1 );
- assert.equal( jQuery("#table").prop("frameBorder"), 1, "Check setting and retrieving frameBorder" );
-});
+ assert.equal( jQuery( "#listWithTabIndex" ).prop( "tabindex" ), 5, "Check retrieving tabindex" );
+ jQuery( "#text1" ).prop( "readonly", true );
+ assert.equal( document.getElementById( "text1" ).readOnly, true, "Check setting readOnly property with 'readonly'" );
+ assert.equal( jQuery( "#label-for" ).prop( "for" ), "action", "Check retrieving htmlFor" );
+ jQuery( "#text1" ).prop( "class", "test" );
+ assert.equal( document.getElementById( "text1" ).className, "test", "Check setting className with 'class'" );
+ assert.equal( jQuery( "#text1" ).prop( "maxlength" ), 30, "Check retrieving maxLength" );
+ jQuery( "#table" ).prop( "cellspacing", 1 );
+ assert.equal( jQuery( "#table" ).prop( "cellSpacing" ), "1", "Check setting and retrieving cellSpacing" );
+ jQuery( "#table" ).prop( "cellpadding", 1 );
+ assert.equal( jQuery( "#table" ).prop( "cellPadding" ), "1", "Check setting and retrieving cellPadding" );
+ jQuery( "#table" ).prop( "rowspan", 1 );
+ assert.equal( jQuery( "#table" ).prop( "rowSpan" ), 1, "Check setting and retrieving rowSpan" );
+ jQuery( "#table" ).prop( "colspan", 1 );
+ assert.equal( jQuery( "#table" ).prop( "colSpan" ), 1, "Check setting and retrieving colSpan" );
+ jQuery( "#table" ).prop( "usemap", 1 );
+ assert.equal( jQuery( "#table" ).prop( "useMap" ), 1, "Check setting and retrieving useMap" );
+ jQuery( "#table" ).prop( "frameborder", 1 );
+ assert.equal( jQuery( "#table" ).prop( "frameBorder" ), 1, "Check setting and retrieving frameBorder" );
+} );
QUnit.test( "prop(String, Object) on null/undefined", function( assert ) {
@@ -675,243 +676,243 @@ QUnit.test( "prop(String, Object) on null/undefined", function( assert ) {
body = document.body,
$body = jQuery( body );
- assert.ok( $body.prop("nextSibling") === null, "Make sure a null expando returns null" );
- body["foo"] = "bar";
- assert.equal( $body.prop("foo"), "bar", "Make sure the expando is preferred over the dom attribute" );
- body["foo"] = undefined;
- assert.ok( $body.prop("foo") === undefined, "Make sure the expando is preferred over the dom attribute, even if undefined" );
+ assert.ok( $body.prop( "nextSibling" ) === null, "Make sure a null expando returns null" );
+ body[ "foo" ] = "bar";
+ assert.equal( $body.prop( "foo" ), "bar", "Make sure the expando is preferred over the dom attribute" );
+ body[ "foo" ] = undefined;
+ assert.ok( $body.prop( "foo" ) === undefined, "Make sure the expando is preferred over the dom attribute, even if undefined" );
- select = document.createElement("select");
- optgroup = document.createElement("optgroup");
- option = document.createElement("option");
+ select = document.createElement( "select" );
+ optgroup = document.createElement( "optgroup" );
+ option = document.createElement( "option" );
optgroup.appendChild( option );
select.appendChild( optgroup );
- assert.equal( jQuery( option ).prop("selected"), true, "Make sure that a single option is selected, even when in an optgroup." );
- assert.equal( jQuery( document ).prop("nodeName"), "#document", "prop works correctly on document nodes (bug #7451)." );
+ assert.equal( jQuery( option ).prop( "selected" ), true, "Make sure that a single option is selected, even when in an optgroup." );
+ assert.equal( jQuery( document ).prop( "nodeName" ), "#document", "prop works correctly on document nodes (bug #7451)." );
- attributeNode = document.createAttribute("irrelevant");
- commentNode = document.createComment("some comment");
- textNode = document.createTextNode("some text");
+ attributeNode = document.createAttribute( "irrelevant" );
+ commentNode = document.createComment( "some comment" );
+ textNode = document.createTextNode( "some text" );
obj = {};
jQuery.each( [ document, attributeNode, commentNode, textNode, obj, "#firstp" ], function( i, ele ) {
- assert.strictEqual( jQuery( ele ).prop("nonexisting"), undefined, "prop works correctly for non existing attributes (bug #7500)." );
- });
+ assert.strictEqual( jQuery( ele ).prop( "nonexisting" ), undefined, "prop works correctly for non existing attributes (bug #7500)." );
+ } );
obj = {};
jQuery.each( [ document, obj ], function( i, ele ) {
var $ele = jQuery( ele );
$ele.prop( "nonexisting", "foo" );
- assert.equal( $ele.prop("nonexisting"), "foo", "prop(name, value) works correctly for non existing attributes (bug #7500)." );
- });
- jQuery( document ).removeProp("nonexisting");
+ assert.equal( $ele.prop( "nonexisting" ), "foo", "prop(name, value) works correctly for non existing attributes (bug #7500)." );
+ } );
+ jQuery( document ).removeProp( "nonexisting" );
- $form = jQuery("#form").prop( "enctype", "multipart/form-data" );
- assert.equal( $form.prop("enctype"), "multipart/form-data", "Set the enctype of a form (encoding in IE6/7 #6743)" );
-});
+ $form = jQuery( "#form" ).prop( "enctype", "multipart/form-data" );
+ assert.equal( $form.prop( "enctype" ), "multipart/form-data", "Set the enctype of a form (encoding in IE6/7 #6743)" );
+} );
QUnit.test( "prop('tabindex')", function( assert ) {
assert.expect( 11 );
// inputs without tabIndex attribute
- assert.equal( jQuery("#inputWithoutTabIndex").prop("tabindex"), 0, "input without tabindex" );
- assert.equal( jQuery("#buttonWithoutTabIndex").prop("tabindex"), 0, "button without tabindex" );
- assert.equal( jQuery("#textareaWithoutTabIndex").prop("tabindex"), 0, "textarea without tabindex" );
+ assert.equal( jQuery( "#inputWithoutTabIndex" ).prop( "tabindex" ), 0, "input without tabindex" );
+ assert.equal( jQuery( "#buttonWithoutTabIndex" ).prop( "tabindex" ), 0, "button without tabindex" );
+ assert.equal( jQuery( "#textareaWithoutTabIndex" ).prop( "tabindex" ), 0, "textarea without tabindex" );
// elements not natively tabbable
- assert.equal( jQuery("#listWithTabIndex").prop("tabindex"), 5, "not natively tabbable, with tabindex set to 0" );
- assert.equal( jQuery("#divWithNoTabIndex").prop("tabindex"), -1, "not natively tabbable, no tabindex set" );
+ assert.equal( jQuery( "#listWithTabIndex" ).prop( "tabindex" ), 5, "not natively tabbable, with tabindex set to 0" );
+ assert.equal( jQuery( "#divWithNoTabIndex" ).prop( "tabindex" ), -1, "not natively tabbable, no tabindex set" );
// anchor with href
- assert.equal( jQuery("#linkWithNoTabIndex").prop("tabindex"), 0, "anchor with href, no tabindex set" );
- assert.equal( jQuery("#linkWithTabIndex").prop("tabindex"), 2, "anchor with href, tabindex set to 2" );
- assert.equal( jQuery("#linkWithNegativeTabIndex").prop("tabindex"), -1, "anchor with href, tabindex set to -1" );
+ assert.equal( jQuery( "#linkWithNoTabIndex" ).prop( "tabindex" ), 0, "anchor with href, no tabindex set" );
+ assert.equal( jQuery( "#linkWithTabIndex" ).prop( "tabindex" ), 2, "anchor with href, tabindex set to 2" );
+ assert.equal( jQuery( "#linkWithNegativeTabIndex" ).prop( "tabindex" ), -1, "anchor with href, tabindex set to -1" );
// anchor without href
- assert.equal( jQuery("#linkWithNoHrefWithNoTabIndex").prop("tabindex"), -1, "anchor without href, no tabindex set" );
- assert.equal( jQuery("#linkWithNoHrefWithTabIndex").prop("tabindex"), 1, "anchor without href, tabindex set to 2" );
- assert.equal( jQuery("#linkWithNoHrefWithNegativeTabIndex").prop("tabindex"), -1, "anchor without href, no tabindex set" );
-});
+ assert.equal( jQuery( "#linkWithNoHrefWithNoTabIndex" ).prop( "tabindex" ), -1, "anchor without href, no tabindex set" );
+ assert.equal( jQuery( "#linkWithNoHrefWithTabIndex" ).prop( "tabindex" ), 1, "anchor without href, tabindex set to 2" );
+ assert.equal( jQuery( "#linkWithNoHrefWithNegativeTabIndex" ).prop( "tabindex" ), -1, "anchor without href, no tabindex set" );
+} );
QUnit.test( "prop('tabindex', value)", function( assert ) {
assert.expect( 10 );
var clone,
- element = jQuery("#divWithNoTabIndex");
+ element = jQuery( "#divWithNoTabIndex" );
- assert.equal( element.prop("tabindex"), -1, "start with no tabindex" );
+ assert.equal( element.prop( "tabindex" ), -1, "start with no tabindex" );
// set a positive string
element.prop( "tabindex", "1" );
- assert.equal( element.prop("tabindex"), 1, "set tabindex to 1 (string)" );
+ assert.equal( element.prop( "tabindex" ), 1, "set tabindex to 1 (string)" );
// set a zero string
element.prop( "tabindex", "0" );
- assert.equal( element.prop("tabindex"), 0, "set tabindex to 0 (string)" );
+ assert.equal( element.prop( "tabindex" ), 0, "set tabindex to 0 (string)" );
// set a negative string
element.prop( "tabindex", "-1" );
- assert.equal( element.prop("tabindex"), -1, "set tabindex to -1 (string)" );
+ assert.equal( element.prop( "tabindex" ), -1, "set tabindex to -1 (string)" );
// set a positive number
element.prop( "tabindex", 1 );
- assert.equal( element.prop("tabindex"), 1, "set tabindex to 1 (number)" );
+ assert.equal( element.prop( "tabindex" ), 1, "set tabindex to 1 (number)" );
// set a zero number
element.prop( "tabindex", 0 );
- assert.equal( element.prop("tabindex"), 0, "set tabindex to 0 (number)" );
+ assert.equal( element.prop( "tabindex" ), 0, "set tabindex to 0 (number)" );
// set a negative number
element.prop( "tabindex", -1 );
- assert.equal( element.prop("tabindex"), -1, "set tabindex to -1 (number)" );
+ assert.equal( element.prop( "tabindex" ), -1, "set tabindex to -1 (number)" );
- element = jQuery("#linkWithTabIndex");
- assert.equal( element.prop("tabindex"), 2, "start with tabindex 2" );
+ element = jQuery( "#linkWithTabIndex" );
+ assert.equal( element.prop( "tabindex" ), 2, "start with tabindex 2" );
element.prop( "tabindex", -1 );
- assert.equal( element.prop("tabindex"), -1, "set negative tabindex" );
+ assert.equal( element.prop( "tabindex" ), -1, "set negative tabindex" );
clone = element.clone();
clone.prop( "tabindex", 1 );
- assert.equal( clone[ 0 ].getAttribute("tabindex"), "1", "set tabindex on cloned element" );
-});
+ assert.equal( clone[ 0 ].getAttribute( "tabindex" ), "1", "set tabindex on cloned element" );
+} );
QUnit.test( "removeProp(String)", function( assert ) {
assert.expect( 6 );
- var attributeNode = document.createAttribute("irrelevant"),
- commentNode = document.createComment("some comment"),
- textNode = document.createTextNode("some text"),
+ var attributeNode = document.createAttribute( "irrelevant" ),
+ commentNode = document.createComment( "some comment" ),
+ textNode = document.createTextNode( "some text" ),
obj = {};
assert.strictEqual(
- jQuery( "#firstp" ).prop( "nonexisting", "foo" ).removeProp( "nonexisting" )[ 0 ]["nonexisting"],
+ jQuery( "#firstp" ).prop( "nonexisting", "foo" ).removeProp( "nonexisting" )[ 0 ][ "nonexisting" ],
undefined,
"removeprop works correctly on DOM element nodes"
);
jQuery.each( [ document, obj ], function( i, ele ) {
var $ele = jQuery( ele );
- $ele.prop( "nonexisting", "foo" ).removeProp("nonexisting");
- assert.strictEqual( ele["nonexisting"], undefined, "removeProp works correctly on non DOM element nodes (bug #7500)." );
- });
+ $ele.prop( "nonexisting", "foo" ).removeProp( "nonexisting" );
+ assert.strictEqual( ele[ "nonexisting" ], undefined, "removeProp works correctly on non DOM element nodes (bug #7500)." );
+ } );
jQuery.each( [ commentNode, textNode, attributeNode ], function( i, ele ) {
var $ele = jQuery( ele );
- $ele.prop( "nonexisting", "foo" ).removeProp("nonexisting");
- assert.strictEqual( ele["nonexisting"], undefined, "removeProp works correctly on non DOM element nodes (bug #7500)." );
- });
-});
+ $ele.prop( "nonexisting", "foo" ).removeProp( "nonexisting" );
+ assert.strictEqual( ele[ "nonexisting" ], undefined, "removeProp works correctly on non DOM element nodes (bug #7500)." );
+ } );
+} );
QUnit.test( "val() after modification", function( assert ) {
assert.expect( 1 );
- document.getElementById("text1").value = "bla";
- assert.equal( jQuery("#text1").val(), "bla", "Check for modified value of input element" );
-});
-
+ document.getElementById( "text1" ).value = "bla";
+ assert.equal( jQuery( "#text1" ).val(), "bla", "Check for modified value of input element" );
+} );
QUnit.test( "val()", function( assert ) {
assert.expect( 20 + ( jQuery.fn.serialize ? 6 : 0 ) );
var checks, $button;
- assert.equal( jQuery("#text1").val(), "Test", "Check for value of input element" );
+ assert.equal( jQuery( "#text1" ).val(), "Test", "Check for value of input element" );
+
// ticket #1714 this caused a JS error in IE
- assert.equal( jQuery("#first").val(), "", "Check a paragraph element to see if it has a value" );
- assert.ok( jQuery([]).val() === undefined, "Check an empty jQuery object will return undefined from val" );
+ assert.equal( jQuery( "#first" ).val(), "", "Check a paragraph element to see if it has a value" );
+ assert.ok( jQuery( [] ).val() === undefined, "Check an empty jQuery object will return undefined from val" );
- assert.equal( jQuery("#select2").val(), "3", "Call val() on a single='single' select" );
+ assert.equal( jQuery( "#select2" ).val(), "3", "Call val() on a single='single' select" );
- assert.deepEqual( jQuery("#select3").val(), [ "1", "2" ], "Call val() on a multiple='multiple' select" );
+ assert.deepEqual( jQuery( "#select3" ).val(), [ "1", "2" ], "Call val() on a multiple='multiple' select" );
- assert.equal( jQuery("#option3c").val(), "2", "Call val() on a option element with value" );
+ assert.equal( jQuery( "#option3c" ).val(), "2", "Call val() on a option element with value" );
- assert.equal( jQuery("#option3a").val(), "", "Call val() on a option element with empty value" );
+ assert.equal( jQuery( "#option3a" ).val(), "", "Call val() on a option element with empty value" );
- assert.equal( jQuery("#option3e").val(), "no value", "Call val() on a option element with no value attribute" );
+ assert.equal( jQuery( "#option3e" ).val(), "no value", "Call val() on a option element with no value attribute" );
- assert.equal( jQuery("#option3a").val(), "", "Call val() on a option element with no value attribute" );
+ assert.equal( jQuery( "#option3a" ).val(), "", "Call val() on a option element with no value attribute" );
- jQuery("#select3").val("");
- assert.deepEqual( jQuery("#select3").val(), [""], "Call val() on a multiple='multiple' select" );
+ jQuery( "#select3" ).val( "" );
+ assert.deepEqual( jQuery( "#select3" ).val(), [ "" ], "Call val() on a multiple='multiple' select" );
- assert.deepEqual( jQuery("#select4").val(), [], "Call val() on multiple='multiple' select with all disabled options" );
+ assert.deepEqual( jQuery( "#select4" ).val(), [], "Call val() on multiple='multiple' select with all disabled options" );
- jQuery("#select4 optgroup").add("#select4 > [disabled]").attr( "disabled", false );
- assert.deepEqual( jQuery("#select4").val(), [ "2", "3" ], "Call val() on multiple='multiple' select with some disabled options" );
+ jQuery( "#select4 optgroup" ).add( "#select4 > [disabled]" ).attr( "disabled", false );
+ assert.deepEqual( jQuery( "#select4" ).val(), [ "2", "3" ], "Call val() on multiple='multiple' select with some disabled options" );
- jQuery("#select4").attr( "disabled", true );
- assert.deepEqual( jQuery("#select4").val(), [ "2", "3" ], "Call val() on disabled multiple='multiple' select" );
+ jQuery( "#select4" ).attr( "disabled", true );
+ assert.deepEqual( jQuery( "#select4" ).val(), [ "2", "3" ], "Call val() on disabled multiple='multiple' select" );
- assert.equal( jQuery("#select5").val(), "3", "Check value on ambiguous select." );
+ assert.equal( jQuery( "#select5" ).val(), "3", "Check value on ambiguous select." );
- jQuery("#select5").val( 1 );
- assert.equal( jQuery("#select5").val(), "1", "Check value on ambiguous select." );
+ jQuery( "#select5" ).val( 1 );
+ assert.equal( jQuery( "#select5" ).val(), "1", "Check value on ambiguous select." );
- jQuery("#select5").val( 3 );
- assert.equal( jQuery("#select5").val(), "3", "Check value on ambiguous select." );
+ jQuery( "#select5" ).val( 3 );
+ assert.equal( jQuery( "#select5" ).val(), "3", "Check value on ambiguous select." );
assert.strictEqual(
- jQuery("
1 ").val(),
+ jQuery( "
1 " ).val(),
null,
"Select-one with only option disabled (#12584)"
);
if ( jQuery.fn.serialize ) {
- checks = jQuery("
").appendTo("#form");
+ checks = jQuery( "
" ).appendTo( "#form" );
assert.deepEqual( checks.serialize(), "", "Get unchecked values." );
assert.equal( checks.eq( 3 ).val(), "on", "Make sure a value of 'on' is provided if none is specified." );
- checks.val([ "2" ]);
+ checks.val( [ "2" ] );
assert.deepEqual( checks.serialize(), "test=2", "Get a single checked value." );
- checks.val([ "1", "" ]);
+ checks.val( [ "1", "" ] );
assert.deepEqual( checks.serialize(), "test=1&test=", "Get multiple checked values." );
- checks.val([ "", "2" ]);
+ checks.val( [ "", "2" ] );
assert.deepEqual( checks.serialize(), "test=2&test=", "Get multiple checked values." );
- checks.val([ "1", "on" ]);
+ checks.val( [ "1", "on" ] );
assert.deepEqual( checks.serialize(), "test=1&test=on", "Get multiple checked values." );
checks.remove();
}
- $button = jQuery("
text ").insertAfter("#button");
+ $button = jQuery( "
text " ).insertAfter( "#button" );
assert.equal( $button.val(), "foobar", "Value retrieval on a button does not return innerHTML" );
- assert.equal( $button.val("baz").html(), "text", "Setting the value does not change innerHTML" );
+ assert.equal( $button.val( "baz" ).html(), "text", "Setting the value does not change innerHTML" );
- assert.equal( jQuery("
").val("test").attr("value"), "test", "Setting value sets the value attribute" );
-});
+ assert.equal( jQuery( "
" ).val( "test" ).attr( "value" ), "test", "Setting value sets the value attribute" );
+} );
-QUnit.test("val() with non-matching values on dropdown list", function( assert ) {
+QUnit.test( "val() with non-matching values on dropdown list", function( assert ) {
assert.expect( 3 );
- jQuery("#select5").val( "" );
- assert.equal( jQuery("#select5").val(), null, "Non-matching set on select-one" );
+ jQuery( "#select5" ).val( "" );
+ assert.equal( jQuery( "#select5" ).val(), null, "Non-matching set on select-one" );
- var select6 = jQuery("
A B ").appendTo("#form");
- jQuery(select6).val( "nothing" );
- assert.equal( jQuery(select6).val(), null, "Non-matching set (single value) on select-multiple" );
+ var select6 = jQuery( "
A B " ).appendTo( "#form" );
+ jQuery( select6 ).val( "nothing" );
+ assert.equal( jQuery( select6 ).val(), null, "Non-matching set (single value) on select-multiple" );
- jQuery(select6).val( ["nothing1", "nothing2"] );
- assert.equal( jQuery(select6).val(), null, "Non-matching set (array of values) on select-multiple" );
+ jQuery( select6 ).val( [ "nothing1", "nothing2" ] );
+ assert.equal( jQuery( select6 ).val(), null, "Non-matching set (array of values) on select-multiple" );
select6.remove();
-});
+} );
-if ( "value" in document.createElement("meter") &&
- "value" in document.createElement("progress") ) {
+if ( "value" in document.createElement( "meter" ) &&
+ "value" in document.createElement( "progress" ) ) {
QUnit.test( "val() respects numbers without exception (Bug #9319)", function( assert ) {
assert.expect( 4 );
- var $meter = jQuery("
"),
- $progress = jQuery("
");
+ var $meter = jQuery( "
" ),
+ $progress = jQuery( "
" );
try {
assert.equal( typeof $meter.val(), "number", "meter, returns a number and does not throw exception" );
@@ -920,47 +921,47 @@ if ( "value" in document.createElement("meter") &&
assert.equal( typeof $progress.val(), "number", "progress, returns a number and does not throw exception" );
assert.equal( $progress.val(), $progress[ 0 ].value, "progress, api matches host and does not throw exception" );
- } catch( e ) {}
+ } catch ( e ) {}
$meter.remove();
$progress.remove();
- });
+ } );
}
var testVal = function( valueObj, assert ) {
assert.expect( 9 );
- jQuery("#text1").val( valueObj("test") );
- assert.equal( document.getElementById("text1").value, "test", "Check for modified (via val(String)) value of input element" );
+ jQuery( "#text1" ).val( valueObj( "test" ) );
+ assert.equal( document.getElementById( "text1" ).value, "test", "Check for modified (via val(String)) value of input element" );
- jQuery("#text1").val( valueObj( undefined ) );
- assert.equal( document.getElementById("text1").value, "", "Check for modified (via val(undefined)) value of input element" );
+ jQuery( "#text1" ).val( valueObj( undefined ) );
+ assert.equal( document.getElementById( "text1" ).value, "", "Check for modified (via val(undefined)) value of input element" );
- jQuery("#text1").val( valueObj( 67 ) );
- assert.equal( document.getElementById("text1").value, "67", "Check for modified (via val(Number)) value of input element" );
+ jQuery( "#text1" ).val( valueObj( 67 ) );
+ assert.equal( document.getElementById( "text1" ).value, "67", "Check for modified (via val(Number)) value of input element" );
- jQuery("#text1").val( valueObj( null ) );
- assert.equal( document.getElementById("text1").value, "", "Check for modified (via val(null)) value of input element" );
+ jQuery( "#text1" ).val( valueObj( null ) );
+ assert.equal( document.getElementById( "text1" ).value, "", "Check for modified (via val(null)) value of input element" );
var j,
$select = jQuery( "
" ),
- $select1 = jQuery("#select1");
+ $select1 = jQuery( "#select1" );
- $select1.val( valueObj("3") );
+ $select1.val( valueObj( "3" ) );
assert.equal( $select1.val(), "3", "Check for modified (via val(String)) value of select element" );
$select1.val( valueObj( 2 ) );
assert.equal( $select1.val(), "2", "Check for modified (via val(Number)) value of select element" );
- $select1.append("
four ");
+ $select1.append( "
four " );
$select1.val( valueObj( 4 ) );
assert.equal( $select1.val(), "4", "Should be possible to set the val() to a newly created option" );
// using contents will get comments regular, text, and comment nodes
- j = jQuery("#nonnodes").contents();
+ j = jQuery( "#nonnodes" ).contents();
j.val( valueObj( "asdf" ) );
assert.equal( j.val(), "asdf", "Check node,textnode,comment with val()" );
- j.removeAttr("value");
+ j.removeAttr( "value" );
$select.val( valueObj( [ "1", "2" ] ) );
assert.deepEqual( $select.val(), [ "1", "2" ], "Should set array of values" );
@@ -968,407 +969,406 @@ var testVal = function( valueObj, assert ) {
QUnit.test( "val(String/Number)", function( assert ) {
testVal( bareObj, assert );
-});
+} );
QUnit.test( "val(Function)", function( assert ) {
testVal( functionReturningObj, assert );
-});
+} );
QUnit.test( "val(Array of Numbers) (Bug #7123)", function( assert ) {
assert.expect( 4 );
- jQuery("#form").append("
");
- var elements = jQuery("input[name=arrayTest]").val([ 1, 2 ]);
+ jQuery( "#form" ).append( "
" );
+ var elements = jQuery( "input[name=arrayTest]" ).val( [ 1, 2 ] );
assert.ok( elements[ 0 ].checked, "First element was checked" );
assert.ok( elements[ 1 ].checked, "Second element was checked" );
assert.ok( !elements[ 2 ].checked, "Third element was unchecked" );
assert.ok( !elements[ 3 ].checked, "Fourth element remained unchecked" );
elements.remove();
-});
+} );
QUnit.test( "val(Function) with incoming value", function( assert ) {
assert.expect( 10 );
- var oldVal = jQuery("#text1").val();
+ var oldVal = jQuery( "#text1" ).val();
- jQuery("#text1").val(function( i, val ) {
+ jQuery( "#text1" ).val( function( i, val ) {
assert.equal( val, oldVal, "Make sure the incoming value is correct." );
return "test";
- });
+ } );
- assert.equal( document.getElementById("text1").value, "test", "Check for modified (via val(String)) value of input element" );
+ assert.equal( document.getElementById( "text1" ).value, "test", "Check for modified (via val(String)) value of input element" );
- oldVal = jQuery("#text1").val();
+ oldVal = jQuery( "#text1" ).val();
- jQuery("#text1").val(function( i, val ) {
+ jQuery( "#text1" ).val( function( i, val ) {
assert.equal( val, oldVal, "Make sure the incoming value is correct." );
return 67;
- });
+ } );
- assert.equal( document.getElementById("text1").value, "67", "Check for modified (via val(Number)) value of input element" );
+ assert.equal( document.getElementById( "text1" ).value, "67", "Check for modified (via val(Number)) value of input element" );
- oldVal = jQuery("#select1").val();
+ oldVal = jQuery( "#select1" ).val();
- jQuery("#select1").val(function( i, val ) {
+ jQuery( "#select1" ).val( function( i, val ) {
assert.equal( val, oldVal, "Make sure the incoming value is correct." );
return "3";
- });
+ } );
- assert.equal( jQuery("#select1").val(), "3", "Check for modified (via val(String)) value of select element" );
+ assert.equal( jQuery( "#select1" ).val(), "3", "Check for modified (via val(String)) value of select element" );
- oldVal = jQuery("#select1").val();
+ oldVal = jQuery( "#select1" ).val();
- jQuery("#select1").val(function( i, val ) {
+ jQuery( "#select1" ).val( function( i, val ) {
assert.equal( val, oldVal, "Make sure the incoming value is correct." );
return 2;
- });
+ } );
- assert.equal( jQuery("#select1").val(), "2", "Check for modified (via val(Number)) value of select element" );
+ assert.equal( jQuery( "#select1" ).val(), "2", "Check for modified (via val(Number)) value of select element" );
- jQuery("#select1").append("
four ");
+ jQuery( "#select1" ).append( "
four " );
- oldVal = jQuery("#select1").val();
+ oldVal = jQuery( "#select1" ).val();
- jQuery("#select1").val(function( i, val ) {
+ jQuery( "#select1" ).val( function( i, val ) {
assert.equal( val, oldVal, "Make sure the incoming value is correct." );
return 4;
- });
+ } );
- assert.equal( jQuery("#select1").val(), "4", "Should be possible to set the val() to a newly created option" );
-});
+ assert.equal( jQuery( "#select1" ).val(), "4", "Should be possible to set the val() to a newly created option" );
+} );
// testing if a form.reset() breaks a subsequent call to a select element's .val() (in IE only)
QUnit.test( "val(select) after form.reset() (Bug #2551)", function( assert ) {
assert.expect( 3 );
- jQuery("
").appendTo("#qunit-fixture");
+ jQuery( "
" ).appendTo( "#qunit-fixture" );
- jQuery("#kkk").val("gf");
+ jQuery( "#kkk" ).val( "gf" );
- document["kk"].reset();
+ document[ "kk" ].reset();
- assert.equal( jQuery("#kkk")[ 0 ].value, "cf", "Check value of select after form reset." );
- assert.equal( jQuery("#kkk").val(), "cf", "Check value of select after form reset." );
+ assert.equal( jQuery( "#kkk" )[ 0 ].value, "cf", "Check value of select after form reset." );
+ assert.equal( jQuery( "#kkk" ).val(), "cf", "Check value of select after form reset." );
// re-verify the multi-select is not broken (after form.reset) by our fix for single-select
- assert.deepEqual( jQuery("#select3").val(), ["1", "2"], "Call val() on a multiple='multiple' select" );
+ assert.deepEqual( jQuery( "#select3" ).val(), [ "1", "2" ], "Call val() on a multiple='multiple' select" );
- jQuery("#kk").remove();
-});
+ jQuery( "#kk" ).remove();
+} );
var testAddClass = function( valueObj, assert ) {
assert.expect( 9 );
var pass, j, i,
- div = jQuery("#qunit-fixture div");
- div.addClass( valueObj("test") );
+ div = jQuery( "#qunit-fixture div" );
+ div.addClass( valueObj( "test" ) );
pass = true;
for ( i = 0; i < div.length; i++ ) {
- if ( !~div.get( i ).className.indexOf("test") ) {
+ if ( !~div.get( i ).className.indexOf( "test" ) ) {
pass = false;
}
}
assert.ok( pass, "Add Class" );
// using contents will get regular, text, and comment nodes
- j = jQuery("#nonnodes").contents();
- j.addClass( valueObj("asdf") );
- assert.ok( j.hasClass("asdf"), "Check node,textnode,comment for addClass" );
+ j = jQuery( "#nonnodes" ).contents();
+ j.addClass( valueObj( "asdf" ) );
+ assert.ok( j.hasClass( "asdf" ), "Check node,textnode,comment for addClass" );
- div = jQuery("
");
+ div = jQuery( "
" );
- div.addClass( valueObj("test") );
- assert.equal( div.attr("class"), "test", "Make sure there's no extra whitespace." );
+ div.addClass( valueObj( "test" ) );
+ assert.equal( div.attr( "class" ), "test", "Make sure there's no extra whitespace." );
div.attr( "class", " foo" );
- div.addClass( valueObj("test") );
- assert.equal( div.attr("class"), "foo test", "Make sure there's no extra whitespace." );
+ div.addClass( valueObj( "test" ) );
+ assert.equal( div.attr( "class" ), "foo test", "Make sure there's no extra whitespace." );
div.attr( "class", "foo" );
- div.addClass( valueObj("bar baz") );
- assert.equal( div.attr("class"), "foo bar baz", "Make sure there isn't too much trimming." );
+ div.addClass( valueObj( "bar baz" ) );
+ assert.equal( div.attr( "class" ), "foo bar baz", "Make sure there isn't too much trimming." );
div.removeClass();
- div.addClass( valueObj("foo") ).addClass( valueObj("foo") );
- assert.equal( div.attr("class"), "foo", "Do not add the same class twice in separate calls." );
+ div.addClass( valueObj( "foo" ) ).addClass( valueObj( "foo" ) );
+ assert.equal( div.attr( "class" ), "foo", "Do not add the same class twice in separate calls." );
- div.addClass( valueObj("fo") );
- assert.equal( div.attr("class"), "foo fo", "Adding a similar class does not get interrupted." );
- div.removeClass().addClass("wrap2");
- assert.ok( div.addClass("wrap").hasClass("wrap"), "Can add similarly named classes");
+ div.addClass( valueObj( "fo" ) );
+ assert.equal( div.attr( "class" ), "foo fo", "Adding a similar class does not get interrupted." );
+ div.removeClass().addClass( "wrap2" );
+ assert.ok( div.addClass( "wrap" ).hasClass( "wrap" ), "Can add similarly named classes" );
div.removeClass();
- div.addClass( valueObj("bar bar") );
- assert.equal( div.attr("class"), "bar", "Do not add the same class twice in the same call." );
+ div.addClass( valueObj( "bar bar" ) );
+ assert.equal( div.attr( "class" ), "bar", "Do not add the same class twice in the same call." );
};
QUnit.test( "addClass(String)", function( assert ) {
testAddClass( bareObj, assert );
-});
+} );
QUnit.test( "addClass(Function)", function( assert ) {
testAddClass( functionReturningObj, assert );
-});
+} );
QUnit.test( "addClass(Function) with incoming value", function( assert ) {
assert.expect( 52 );
var pass, i,
- div = jQuery("#qunit-fixture div"),
- old = div.map(function() {
- return jQuery(this).attr("class") || "";
- });
+ div = jQuery( "#qunit-fixture div" ),
+ old = div.map( function() {
+ return jQuery( this ).attr( "class" ) || "";
+ } );
- div.addClass(function( i, val ) {
+ div.addClass( function( i, val ) {
if ( this.id !== "_firebugConsole" ) {
assert.equal( val, old[ i ], "Make sure the incoming value is correct." );
return "test";
}
- });
+ } );
pass = true;
for ( i = 0; i < div.length; i++ ) {
- if ( div.get(i).className.indexOf("test") === -1 ) {
+ if ( div.get( i ).className.indexOf( "test" ) === -1 ) {
pass = false;
}
}
assert.ok( pass, "Add Class" );
-});
+} );
var testRemoveClass = function( valueObj, assert ) {
assert.expect( 8 );
- var $set = jQuery("#qunit-fixture div"),
- div = document.createElement("div");
+ var $set = jQuery( "#qunit-fixture div" ),
+ div = document.createElement( "div" );
- $set.addClass("test").removeClass( valueObj("test") );
+ $set.addClass( "test" ).removeClass( valueObj( "test" ) );
- assert.ok( !$set.is(".test"), "Remove Class" );
+ assert.ok( !$set.is( ".test" ), "Remove Class" );
- $set.addClass("test").addClass("foo").addClass("bar");
- $set.removeClass( valueObj("test") ).removeClass( valueObj("bar") ).removeClass( valueObj("foo") );
+ $set.addClass( "test" ).addClass( "foo" ).addClass( "bar" );
+ $set.removeClass( valueObj( "test" ) ).removeClass( valueObj( "bar" ) ).removeClass( valueObj( "foo" ) );
- assert.ok( !$set.is(".test,.bar,.foo"), "Remove multiple classes" );
+ assert.ok( !$set.is( ".test,.bar,.foo" ), "Remove multiple classes" );
// Make sure that a null value doesn't cause problems
- $set.eq( 0 ).addClass("expected").removeClass( valueObj( null ) );
- assert.ok( $set.eq( 0 ).is(".expected"), "Null value passed to removeClass" );
+ $set.eq( 0 ).addClass( "expected" ).removeClass( valueObj( null ) );
+ assert.ok( $set.eq( 0 ).is( ".expected" ), "Null value passed to removeClass" );
- $set.eq( 0 ).addClass("expected").removeClass( valueObj("") );
- assert.ok( $set.eq( 0 ).is(".expected"), "Empty string passed to removeClass" );
+ $set.eq( 0 ).addClass( "expected" ).removeClass( valueObj( "" ) );
+ assert.ok( $set.eq( 0 ).is( ".expected" ), "Empty string passed to removeClass" );
// using contents will get regular, text, and comment nodes
- $set = jQuery("#nonnodes").contents();
- $set.removeClass( valueObj("asdf") );
- assert.ok( !$set.hasClass("asdf"), "Check node,textnode,comment for removeClass" );
+ $set = jQuery( "#nonnodes" ).contents();
+ $set.removeClass( valueObj( "asdf" ) );
+ assert.ok( !$set.hasClass( "asdf" ), "Check node,textnode,comment for removeClass" );
-
- jQuery( div ).removeClass( valueObj("foo") );
- assert.strictEqual( jQuery( div ).attr("class"), undefined, "removeClass doesn't create a class attribute" );
+ jQuery( div ).removeClass( valueObj( "foo" ) );
+ assert.strictEqual( jQuery( div ).attr( "class" ), undefined, "removeClass doesn't create a class attribute" );
div.className = " test foo ";
- jQuery( div ).removeClass( valueObj("foo") );
+ jQuery( div ).removeClass( valueObj( "foo" ) );
assert.equal( div.className, "test", "Make sure remaining className is trimmed." );
div.className = " test ";
- jQuery( div ).removeClass( valueObj("test") );
+ jQuery( div ).removeClass( valueObj( "test" ) );
assert.equal( div.className, "", "Make sure there is nothing left after everything is removed." );
};
QUnit.test( "removeClass(String) - simple", function( assert ) {
testRemoveClass( bareObj, assert );
-});
+} );
QUnit.test( "removeClass(Function) - simple", function( assert ) {
testRemoveClass( functionReturningObj, assert );
-});
+} );
QUnit.test( "removeClass(Function) with incoming value", function( assert ) {
assert.expect( 52 );
- var $divs = jQuery("#qunit-fixture div").addClass("test"), old = $divs.map(function() {
- return jQuery( this ).attr("class");
- });
+ var $divs = jQuery( "#qunit-fixture div" ).addClass( "test" ), old = $divs.map( function() {
+ return jQuery( this ).attr( "class" );
+ } );
- $divs.removeClass(function( i, val ) {
+ $divs.removeClass( function( i, val ) {
if ( this.id !== "_firebugConsole" ) {
assert.equal( val, old[ i ], "Make sure the incoming value is correct." );
return "test";
}
- });
+ } );
- assert.ok( !$divs.is(".test"), "Remove Class" );
-});
+ assert.ok( !$divs.is( ".test" ), "Remove Class" );
+} );
QUnit.test( "removeClass() removes duplicates", function( assert ) {
assert.expect( 1 );
- var $div = jQuery( jQuery.parseHTML("
") );
+ var $div = jQuery( jQuery.parseHTML( "
" ) );
- $div.removeClass("x");
+ $div.removeClass( "x" );
- assert.ok( !$div.hasClass("x"), "Element with multiple same classes does not escape the wrath of removeClass()" );
-});
+ assert.ok( !$div.hasClass( "x" ), "Element with multiple same classes does not escape the wrath of removeClass()" );
+} );
-QUnit.test("removeClass(undefined) is a no-op", function( assert ) {
+QUnit.test( "removeClass(undefined) is a no-op", function( assert ) {
assert.expect( 1 );
- var $div = jQuery("
");
+ var $div = jQuery( "
" );
$div.removeClass( undefined );
- assert.ok( $div.hasClass("base") && $div.hasClass("second"), "Element still has classes after removeClass(undefined)" );
-});
+ assert.ok( $div.hasClass( "base" ) && $div.hasClass( "second" ), "Element still has classes after removeClass(undefined)" );
+} );
var testToggleClass = function( valueObj, assert ) {
assert.expect( 17 );
- var e = jQuery("#firstp");
- assert.ok( !e.is(".test"), "Assert class not present" );
- e.toggleClass( valueObj("test") );
- assert.ok( e.is(".test"), "Assert class present" );
- e.toggleClass( valueObj("test") );
- assert.ok( !e.is(".test"), "Assert class not present" );
+ var e = jQuery( "#firstp" );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
+ e.toggleClass( valueObj( "test" ) );
+ assert.ok( e.is( ".test" ), "Assert class present" );
+ e.toggleClass( valueObj( "test" ) );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
// class name with a boolean
- e.toggleClass( valueObj("test"), false );
- assert.ok( !e.is(".test"), "Assert class not present" );
- e.toggleClass( valueObj("test"), true );
- assert.ok( e.is(".test"), "Assert class present" );
- e.toggleClass( valueObj("test"), false );
- assert.ok( !e.is(".test"), "Assert class not present" );
+ e.toggleClass( valueObj( "test" ), false );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
+ e.toggleClass( valueObj( "test" ), true );
+ assert.ok( e.is( ".test" ), "Assert class present" );
+ e.toggleClass( valueObj( "test" ), false );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
// multiple class names
- e.addClass("testA testB");
- assert.ok( e.is(".testA.testB"), "Assert 2 different classes present" );
- e.toggleClass( valueObj("testB testC") );
- assert.ok( (e.is(".testA.testC") && !e.is(".testB")), "Assert 1 class added, 1 class removed, and 1 class kept" );
- e.toggleClass( valueObj("testA testC") );
- assert.ok( (!e.is(".testA") && !e.is(".testB") && !e.is(".testC")), "Assert no class present" );
+ e.addClass( "testA testB" );
+ assert.ok( e.is( ".testA.testB" ), "Assert 2 different classes present" );
+ e.toggleClass( valueObj( "testB testC" ) );
+ assert.ok( ( e.is( ".testA.testC" ) && !e.is( ".testB" ) ), "Assert 1 class added, 1 class removed, and 1 class kept" );
+ e.toggleClass( valueObj( "testA testC" ) );
+ assert.ok( ( !e.is( ".testA" ) && !e.is( ".testB" ) && !e.is( ".testC" ) ), "Assert no class present" );
// toggleClass storage
e.toggleClass( true );
assert.ok( e[ 0 ].className === "", "Assert class is empty (data was empty)" );
- e.addClass("testD testE");
- assert.ok( e.is(".testD.testE"), "Assert class present" );
+ e.addClass( "testD testE" );
+ assert.ok( e.is( ".testD.testE" ), "Assert class present" );
e.toggleClass();
- assert.ok( !e.is(".testD.testE"), "Assert class not present" );
- assert.ok( jQuery._data(e[ 0 ], "__className__") === "testD testE", "Assert data was stored" );
+ assert.ok( !e.is( ".testD.testE" ), "Assert class not present" );
+ assert.ok( jQuery._data( e[ 0 ], "__className__" ) === "testD testE", "Assert data was stored" );
e.toggleClass();
- assert.ok( e.is(".testD.testE"), "Assert class present (restored from data)" );
+ assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" );
e.toggleClass( false );
- assert.ok( !e.is(".testD.testE"), "Assert class not present" );
+ assert.ok( !e.is( ".testD.testE" ), "Assert class not present" );
e.toggleClass( true );
- assert.ok( e.is(".testD.testE"), "Assert class present (restored from data)" );
+ assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" );
e.toggleClass();
e.toggleClass( false );
e.toggleClass();
- assert.ok( e.is(".testD.testE"), "Assert class present (restored from data)" );
+ assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" );
// Cleanup
- e.removeClass("testD");
+ e.removeClass( "testD" );
QUnit.expectJqData( this, e[ 0 ], "__className__" );
};
QUnit.test( "toggleClass(String|boolean|undefined[, boolean])", function( assert ) {
testToggleClass( bareObj, assert );
-});
+} );
QUnit.test( "toggleClass(Function[, boolean])", function( assert ) {
testToggleClass( functionReturningObj, assert );
-});
+} );
QUnit.test( "toggleClass(Function[, boolean]) with incoming value", function( assert ) {
assert.expect( 14 );
- var e = jQuery("#firstp"),
- old = e.attr("class") || "";
+ var e = jQuery( "#firstp" ),
+ old = e.attr( "class" ) || "";
- assert.ok( !e.is(".test"), "Assert class not present" );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
- e.toggleClass(function( i, val ) {
+ e.toggleClass( function( i, val ) {
assert.equal( old, val, "Make sure the incoming value is correct." );
return "test";
- });
- assert.ok( e.is(".test"), "Assert class present" );
+ } );
+ assert.ok( e.is( ".test" ), "Assert class present" );
- old = e.attr("class");
+ old = e.attr( "class" );
- e.toggleClass(function( i, val ) {
+ e.toggleClass( function( i, val ) {
assert.equal( old, val, "Make sure the incoming value is correct." );
return "test";
- });
- assert.ok( !e.is(".test"), "Assert class not present" );
+ } );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
- old = e.attr("class") || "";
+ old = e.attr( "class" ) || "";
// class name with a boolean
- e.toggleClass(function( i, val, state ) {
+ e.toggleClass( function( i, val, state ) {
assert.equal( old, val, "Make sure the incoming value is correct." );
assert.equal( state, false, "Make sure that the state is passed in." );
return "test";
}, false );
- assert.ok( !e.is(".test"), "Assert class not present" );
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
- old = e.attr("class") || "";
+ old = e.attr( "class" ) || "";
- e.toggleClass(function( i, val, state ) {
+ e.toggleClass( function( i, val, state ) {
assert.equal( old, val, "Make sure the incoming value is correct." );
assert.equal( state, true, "Make sure that the state is passed in." );
return "test";
}, true );
- assert.ok( e.is(".test"), "Assert class present" );
+ assert.ok( e.is( ".test" ), "Assert class present" );
- old = e.attr("class");
+ old = e.attr( "class" );
- e.toggleClass(function( i, val, state ) {
+ e.toggleClass( function( i, val, state ) {
assert.equal( old, val, "Make sure the incoming value is correct." );
assert.equal( state, false, "Make sure that the state is passed in." );
return "test";
}, false );
- assert.ok( !e.is(".test"), "Assert class not present" );
-});
+ assert.ok( !e.is( ".test" ), "Assert class not present" );
+} );
QUnit.test( "addClass, removeClass, hasClass", function( assert ) {
assert.expect( 17 );
- var jq = jQuery("
Hi
"), x = jq[ 0 ];
+ var jq = jQuery( "
Hi
" ), x = jq[ 0 ];
- jq.addClass("hi");
+ jq.addClass( "hi" );
assert.equal( x.className, "hi", "Check single added class" );
- jq.addClass("foo bar");
+ jq.addClass( "foo bar" );
assert.equal( x.className, "hi foo bar", "Check more added classes" );
jq.removeClass();
assert.equal( x.className, "", "Remove all classes" );
- jq.addClass("hi foo bar");
- jq.removeClass("foo");
+ jq.addClass( "hi foo bar" );
+ jq.removeClass( "foo" );
assert.equal( x.className, "hi bar", "Check removal of one class" );
- assert.ok( jq.hasClass("hi"), "Check has1" );
- assert.ok( jq.hasClass("bar"), "Check has2" );
+ assert.ok( jq.hasClass( "hi" ), "Check has1" );
+ assert.ok( jq.hasClass( "bar" ), "Check has2" );
- jq = jQuery("
");
+ jq = jQuery( "
" );
- assert.ok( jq.hasClass("class1"), "Check hasClass with line feed" );
- assert.ok( jq.is(".class1"), "Check is with line feed" );
- assert.ok( jq.hasClass("class2"), "Check hasClass with tab" );
- assert.ok( jq.is(".class2"), "Check is with tab" );
- assert.ok( jq.hasClass("cla.ss3"), "Check hasClass with dot" );
- assert.ok( jq.hasClass("class4"), "Check hasClass with carriage return" );
- assert.ok( jq.is(".class4"), "Check is with carriage return" );
+ assert.ok( jq.hasClass( "class1" ), "Check hasClass with line feed" );
+ assert.ok( jq.is( ".class1" ), "Check is with line feed" );
+ assert.ok( jq.hasClass( "class2" ), "Check hasClass with tab" );
+ assert.ok( jq.is( ".class2" ), "Check is with tab" );
+ assert.ok( jq.hasClass( "cla.ss3" ), "Check hasClass with dot" );
+ assert.ok( jq.hasClass( "class4" ), "Check hasClass with carriage return" );
+ assert.ok( jq.is( ".class4" ), "Check is with carriage return" );
- jq.removeClass("class2");
- assert.ok( jq.hasClass("class2") === false, "Check the class has been properly removed" );
- jq.removeClass("cla");
- assert.ok( jq.hasClass("cla.ss3"), "Check the dotted class has not been removed" );
- jq.removeClass("cla.ss3");
- assert.ok( jq.hasClass("cla.ss3") === false, "Check the dotted class has been removed" );
- jq.removeClass("class4");
- assert.ok( jq.hasClass("class4") === false, "Check the class has been properly removed" );
-});
+ jq.removeClass( "class2" );
+ assert.ok( jq.hasClass( "class2" ) === false, "Check the class has been properly removed" );
+ jq.removeClass( "cla" );
+ assert.ok( jq.hasClass( "cla.ss3" ), "Check the dotted class has not been removed" );
+ jq.removeClass( "cla.ss3" );
+ assert.ok( jq.hasClass( "cla.ss3" ) === false, "Check the dotted class has been removed" );
+ jq.removeClass( "class4" );
+ assert.ok( jq.hasClass( "class4" ) === false, "Check the class has been properly removed" );
+} );
QUnit.test( "addClass, removeClass, hasClass on many elements", function( assert ) {
assert.expect( 19 );
@@ -1411,17 +1411,17 @@ QUnit.test( "addClass, removeClass, hasClass on many elements", function( assert
assert.ok( !jQuery( "
p0
p1
p2
" ).hasClass( "hi" ),
"Did not find a class when not present" );
-});
+} );
QUnit.test( "contents().hasClass() returns correct values", function( assert ) {
assert.expect( 2 );
- var $div = jQuery("
"),
+ var $div = jQuery( "
" ),
$contents = $div.contents();
- assert.ok( $contents.hasClass("foo"), "Found 'foo' in $contents" );
- assert.ok( !$contents.hasClass("undefined"), "Did not find 'undefined' in $contents (correctly)" );
-});
+ assert.ok( $contents.hasClass( "foo" ), "Found 'foo' in $contents" );
+ assert.ok( !$contents.hasClass( "undefined" ), "Did not find 'undefined' in $contents (correctly)" );
+} );
QUnit.test( "hasClass correctly interprets non-space separators (#13835)", function( assert ) {
assert.expect( 4 );
@@ -1435,23 +1435,23 @@ QUnit.test( "hasClass correctly interprets non-space separators (#13835)", funct
},
classes = jQuery.map( map, function( separator, label ) {
return " " + separator + label + separator + " ";
- }),
+ } ),
$div = jQuery( "
" );
jQuery.each( map, function( label ) {
assert.ok( $div.hasClass( label ), label.replace( "-", " " ) );
- });
-});
+ } );
+} );
QUnit.test( "coords returns correct values in IE6/IE7, see #10828", function( assert ) {
assert.expect( 1 );
var area,
- map = jQuery("
");
+ map = jQuery( "
" );
- area = map.html("
").find("area");
- assert.equal( area.attr("coords"), "0,0,0,0", "did not retrieve coords correctly" );
-});
+ area = map.html( "
" ).find( "area" );
+ assert.equal( area.attr( "coords" ), "0,0,0,0", "did not retrieve coords correctly" );
+} );
QUnit.test( "should not throw at $(option).val() (#14686)", function( assert ) {
assert.expect( 1 );
@@ -1462,12 +1462,12 @@ QUnit.test( "should not throw at $(option).val() (#14686)", function( assert ) {
} catch ( _ ) {
assert.ok( false );
}
-});
+} );
QUnit.test( "option value not trimmed when setting via parent select", function( assert ) {
assert.expect( 1 );
assert.equal( jQuery( "
2 " ).val( "2" ).val(), "2" );
-});
+} );
QUnit.test( "Insignificant white space returned for $(option).val() (#14858)", function( assert ) {
expect ( 3 );
@@ -1480,7 +1480,7 @@ QUnit.test( "Insignificant white space returned for $(option).val() (#14858)", f
val = jQuery( "
test " ).val();
assert.equal( val.length, 4, "insignificant white-space returned for value" );
-});
+} );
QUnit.test( "SVG class manipulation (gh-2199)", function( assert ) {
assert.expect( 12 );
@@ -1489,7 +1489,7 @@ QUnit.test( "SVG class manipulation (gh-2199)", function( assert ) {
return document.createElementNS( "http://www.w3.org/2000/svg", nodeName );
}
- jQuery.each([
+ jQuery.each( [
"svg",
"rect",
"g"
@@ -1507,5 +1507,5 @@ QUnit.test( "SVG class manipulation (gh-2199)", function( assert ) {
elem.toggleClass( "awesome" );
assert.ok( !elem.hasClass( "awesome" ), "SVG element (" + this + ") toggles the class off" );
- });
-});
+ } );
+} );
diff --git a/test/unit/callbacks.js b/test/unit/callbacks.js
index af33174d4..c6c379ded 100644
--- a/test/unit/callbacks.js
+++ b/test/unit/callbacks.js
@@ -1,8 +1,8 @@
QUnit.module( "callbacks", {
teardown: moduleTeardown
-});
+} );
-(function() {
+( function() {
var output,
addToOutput = function( string ) {
@@ -10,9 +10,9 @@ var output,
output += string;
};
},
- outputA = addToOutput("A"),
- outputB = addToOutput("B"),
- outputC = addToOutput("C"),
+ outputA = addToOutput( "A" ),
+ outputB = addToOutput( "B" ),
+ outputC = addToOutput( "C" ),
tests = {
"": "XABC X XABCABCC X XBB X XABA X XX",
"once": "XABC X X X X X XABA X XX",
@@ -54,11 +54,11 @@ jQuery.each( tests, function( strFlags, resultString ) {
if ( this.length ) {
objectFlags[ this ] = true;
}
- });
+ } );
jQuery.each( filters, function( filterLabel ) {
- jQuery.each({
+ jQuery.each( {
"string": strFlags,
"object": objectFlags
}, function( flagsTypes, flags ) {
@@ -76,20 +76,20 @@ jQuery.each( tests, function( strFlags, resultString ) {
assert.strictEqual( cblist.locked(), false, ".locked() initially false" );
assert.strictEqual( cblist.disabled(), false, ".disabled() initially false" );
assert.strictEqual( cblist.fired(), false, ".fired() initially false" );
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
+ } );
assert.strictEqual( cblist.fired(), false, ".fired() still false after .add" );
cblist.fire( "A" );
assert.strictEqual( output, "XA", "Basic binding and firing" );
assert.strictEqual( cblist.fired(), true, ".fired() detects firing" );
output = "X";
cblist.disable();
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
+ } );
assert.strictEqual( output, "X", "Adding a callback after disabling" );
- cblist.fire("A");
+ cblist.fire( "A" );
assert.strictEqual( output, "X", "Firing after disabling" );
assert.strictEqual( cblist.disabled(), true, ".disabled() becomes true" );
assert.strictEqual( cblist.locked(), true, "disabling locks" );
@@ -113,20 +113,20 @@ jQuery.each( tests, function( strFlags, resultString ) {
// Basic binding and firing (context, arguments)
output = "X";
cblist = jQuery.Callbacks( flags );
- cblist.add(function() {
+ cblist.add( function() {
assert.equal( this, window, "Basic binding and firing (context)" );
output += Array.prototype.join.call( arguments, "" );
- });
+ } );
cblist.fireWith( window, [ "A", "B" ] );
assert.strictEqual( output, "XAB", "Basic binding and firing (arguments)" );
// fireWith with no arguments
output = "";
cblist = jQuery.Callbacks( flags );
- cblist.add(function() {
+ cblist.add( function() {
assert.equal( this, window, "fireWith with no arguments (context is window)" );
assert.strictEqual( arguments.length, 0, "fireWith with no arguments (no arguments)" );
- });
+ } );
cblist.fireWith();
// Basic binding, removing and firing
@@ -150,17 +150,17 @@ jQuery.each( tests, function( strFlags, resultString ) {
// Locking
output = "X";
cblist = jQuery.Callbacks( flags );
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
+ } );
cblist.lock();
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
- cblist.fire("A");
- cblist.add(function( str ) {
+ } );
+ cblist.fire( "A" );
+ cblist.add( function( str ) {
output += str;
- });
+ } );
assert.strictEqual( output, "X", "Lock early" );
assert.strictEqual( cblist.locked(), true, "Locking reflected in accessor" );
@@ -168,16 +168,16 @@ jQuery.each( tests, function( strFlags, resultString ) {
output = "X";
cblist = jQuery.Callbacks( flags );
cblist.add( cblist.lock );
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
+ } );
cblist.fire( "A" );
assert.strictEqual( output, "XA", "Locking doesn't abort execution (gh-1990)" );
// Ordering
output = "X";
cblist = jQuery.Callbacks( flags );
- cblist.add(function() {
+ cblist.add( function() {
cblist.add( outputC );
outputA();
}, outputB );
@@ -186,7 +186,7 @@ jQuery.each( tests, function( strFlags, resultString ) {
// Add and fire again
output = "X";
- cblist.add(function() {
+ cblist.add( function() {
cblist.add( outputC );
outputA();
}, outputB );
@@ -199,23 +199,23 @@ jQuery.each( tests, function( strFlags, resultString ) {
// Multiple fire
output = "X";
cblist = jQuery.Callbacks( flags );
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
- cblist.fire("A");
+ } );
+ cblist.fire( "A" );
assert.strictEqual( output, "XA", "Multiple fire (first fire)" );
output = "X";
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
+ } );
assert.strictEqual( output, results.shift(), "Multiple fire (first new callback)" );
output = "X";
- cblist.fire("B");
+ cblist.fire( "B" );
assert.strictEqual( output, results.shift(), "Multiple fire (second fire)" );
output = "X";
- cblist.add(function( str ) {
+ cblist.add( function( str ) {
output += str;
- });
+ } );
assert.strictEqual( output, results.shift(), "Multiple fire (second new callback)" );
// Return false
@@ -244,12 +244,12 @@ jQuery.each( tests, function( strFlags, resultString ) {
cblist.add( handler );
cblist.fire();
assert.strictEqual( output, results.shift(), "No callback iteration" );
- });
- });
- });
-});
+ } );
+ } );
+ } );
+} );
-})();
+} )();
QUnit.test( "jQuery.Callbacks( options ) - options are copied", function( assert ) {
@@ -263,25 +263,25 @@ QUnit.test( "jQuery.Callbacks( options ) - options are copied", function( assert
fn = function() {
assert.ok( !( count++ ), "called once" );
};
- options["unique"] = false;
+ options[ "unique" ] = false;
cb.add( fn, fn );
cb.fire();
-});
+} );
QUnit.test( "jQuery.Callbacks.fireWith - arguments are copied", function( assert ) {
assert.expect( 1 );
- var cb = jQuery.Callbacks("memory"),
- args = ["hello"];
+ var cb = jQuery.Callbacks( "memory" ),
+ args = [ "hello" ];
cb.fireWith( null, args );
args[ 0 ] = "world";
- cb.add(function( hello ) {
+ cb.add( function( hello ) {
assert.strictEqual( hello, "hello", "arguments are copied internally" );
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Callbacks.remove - should remove all instances", function( assert ) {
@@ -295,8 +295,8 @@ QUnit.test( "jQuery.Callbacks.remove - should remove all instances", function( a
cb.add( fn, fn, function() {
assert.ok( true, "end of test" );
- }).remove( fn ).fire();
-});
+ } ).remove( fn ).fire();
+} );
QUnit.test( "jQuery.Callbacks.has", function( assert ) {
@@ -312,36 +312,36 @@ QUnit.test( "jQuery.Callbacks.has", function( assert ) {
function getC() {
return "C";
}
- cb.add(getA, getB, getC);
+ cb.add( getA, getB, getC );
assert.strictEqual( cb.has(), true, "No arguments to .has() returns whether callback function(s) are attached or not" );
- assert.strictEqual( cb.has(getA), true, "Check if a specific callback function is in the Callbacks list" );
+ assert.strictEqual( cb.has( getA ), true, "Check if a specific callback function is in the Callbacks list" );
- cb.remove(getB);
- assert.strictEqual( cb.has(getB), false, "Remove a specific callback function and make sure its no longer there" );
- assert.strictEqual( cb.has(getA), true, "Remove a specific callback function and make sure other callback function is still there" );
+ cb.remove( getB );
+ assert.strictEqual( cb.has( getB ), false, "Remove a specific callback function and make sure its no longer there" );
+ assert.strictEqual( cb.has( getA ), true, "Remove a specific callback function and make sure other callback function is still there" );
cb.empty();
assert.strictEqual( cb.has(), false, "Empty list and make sure there are no callback function(s)" );
- assert.strictEqual( cb.has(getA), false, "Check for a specific function in an empty() list" );
+ assert.strictEqual( cb.has( getA ), false, "Check for a specific function in an empty() list" );
- cb.add(getA, getB, function(){
+ cb.add( getA, getB, function() {
assert.strictEqual( cb.has(), true, "Check if list has callback function(s) from within a callback function" );
- assert.strictEqual( cb.has(getA), true, "Check if list has a specific callback from within a callback function" );
- }).fire();
+ assert.strictEqual( cb.has( getA ), true, "Check if list has a specific callback from within a callback function" );
+ } ).fire();
assert.strictEqual( cb.has(), true, "Callbacks list has callback function(s) after firing" );
cb.disable();
assert.strictEqual( cb.has(), false, "disabled() list has no callback functions (returns false)" );
- assert.strictEqual( cb.has(getA), false, "Check for a specific function in a disabled() list" );
+ assert.strictEqual( cb.has( getA ), false, "Check for a specific function in a disabled() list" );
- cb = jQuery.Callbacks("unique");
- cb.add(getA);
- cb.add(getA);
+ cb = jQuery.Callbacks( "unique" );
+ cb.add( getA );
+ cb.add( getA );
assert.strictEqual( cb.has(), true, "Check if unique list has callback function(s) attached" );
cb.lock();
assert.strictEqual( cb.has(), false, "locked() list is empty and returns false" );
-});
+} );
QUnit.test( "jQuery.Callbacks() - adding a string doesn't cause a stack overflow", function( assert ) {
@@ -350,7 +350,7 @@ QUnit.test( "jQuery.Callbacks() - adding a string doesn't cause a stack overflow
jQuery.Callbacks().add( "hello world" );
assert.ok( true, "no stack overflow" );
-});
+} );
QUnit.test( "jQuery.Callbacks() - disabled callback doesn't fire (gh-1790)", function( assert ) {
@@ -365,4 +365,4 @@ QUnit.test( "jQuery.Callbacks() - disabled callback doesn't fire (gh-1790)", fun
cb.add( shot );
cb.fire();
assert.ok( !fired, "Disabled callback function didn't fire" );
-});
+} );
diff --git a/test/unit/core.js b/test/unit/core.js
index 1a6cf5e3c..d9ec725c9 100644
--- a/test/unit/core.js
+++ b/test/unit/core.js
@@ -1,7 +1,7 @@
-QUnit.module("core", { teardown: moduleTeardown });
+QUnit.module( "core", { teardown: moduleTeardown } );
-QUnit.test("Basic requirements", function( assert ) {
- assert.expect(7);
+QUnit.test( "Basic requirements", function( assert ) {
+ assert.expect( 7 );
assert.ok( Array.prototype.push, "Array.push()" );
assert.ok( Function.prototype.apply, "Function.apply()" );
assert.ok( document.getElementById, "getElementById" );
@@ -9,15 +9,15 @@ QUnit.test("Basic requirements", function( assert ) {
assert.ok( RegExp, "RegExp" );
assert.ok( jQuery, "jQuery" );
assert.ok( $, "$" );
-});
+} );
-QUnit.test("jQuery()", function( assert ) {
+QUnit.test( "jQuery()", function( assert ) {
var elem, i,
- obj = jQuery("div"),
- code = jQuery("
"),
- img = jQuery("
"),
- div = jQuery("
"),
+ obj = jQuery( "div" ),
+ code = jQuery( "
" ),
+ img = jQuery( "
" ),
+ div = jQuery( "
" ),
exec = false,
expected = 23,
attrObj = {
@@ -30,19 +30,19 @@ QUnit.test("jQuery()", function( assert ) {
// few here but beware of modular builds where these methods may be excluded.
if ( jQuery.fn.click ) {
expected++;
- attrObj["click"] = function() { ok( exec, "Click executed." ); };
+ attrObj[ "click" ] = function() { ok( exec, "Click executed." ); };
}
if ( jQuery.fn.width ) {
expected++;
- attrObj["width"] = 10;
+ attrObj[ "width" ] = 10;
}
if ( jQuery.fn.offset ) {
expected++;
- attrObj["offset"] = { "top": 1, "left": 1 };
+ attrObj[ "offset" ] = { "top": 1, "left": 1 };
}
if ( jQuery.fn.css ) {
expected += 2;
- attrObj["css"] = { "paddingLeft": 1, "paddingRight": 1 };
+ attrObj[ "css" ] = { "paddingLeft": 1, "paddingRight": 1 };
}
if ( jQuery.fn.attr ) {
expected++;
@@ -53,10 +53,10 @@ QUnit.test("jQuery()", function( assert ) {
// Basic constructor's behavior
assert.equal( jQuery().length, 0, "jQuery() === jQuery([])" );
- assert.equal( jQuery(undefined).length, 0, "jQuery(undefined) === jQuery([])" );
- assert.equal( jQuery(null).length, 0, "jQuery(null) === jQuery([])" );
- assert.equal( jQuery("").length, 0, "jQuery('') === jQuery([])" );
- assert.deepEqual( jQuery(obj).get(), obj.get(), "jQuery(jQueryObj) == jQueryObj" );
+ assert.equal( jQuery( undefined ).length, 0, "jQuery(undefined) === jQuery([])" );
+ assert.equal( jQuery( null ).length, 0, "jQuery(null) === jQuery([])" );
+ assert.equal( jQuery( "" ).length, 0, "jQuery('') === jQuery([])" );
+ assert.deepEqual( jQuery( obj ).get(), obj.get(), "jQuery(jQueryObj) == jQueryObj" );
// Invalid #id goes to Sizzle which will throw an error (gh-1682)
try {
@@ -66,7 +66,7 @@ QUnit.test("jQuery()", function( assert ) {
}
// can actually yield more than one, when iframes are included, the window is an array as well
- assert.equal( jQuery(window).length, 1, "Correct number of elements generated for jQuery(window)" );
+ assert.equal( jQuery( window ).length, 1, "Correct number of elements generated for jQuery(window)" );
/*
// disabled since this test was doing nothing. i tried to fix it but i'm not sure
@@ -95,84 +95,84 @@ QUnit.test("jQuery()", function( assert ) {
assert.equal( div.length, 4, "Correct number of elements generated for div hr code b" );
assert.equal( div.parent().length, 0, "Make sure that the generated HTML has no parent." );
- assert.equal( jQuery([1,2,3]).get(1), 2, "Test passing an array to the factory" );
+ assert.equal( jQuery( [ 1,2,3 ] ).get( 1 ), 2, "Test passing an array to the factory" );
- assert.equal( jQuery(document.body).get(0), jQuery("body").get(0), "Test passing an html node to the factory" );
+ assert.equal( jQuery( document.body ).get( 0 ), jQuery( "body" ).get( 0 ), "Test passing an html node to the factory" );
- elem = jQuery("
hello ")[0];
+ elem = jQuery( "
hello " )[ 0 ];
assert.equal( elem.nodeName.toLowerCase(), "em", "leading space" );
- elem = jQuery("\n\n
world ")[0];
+ elem = jQuery( "\n\n
world " )[ 0 ];
assert.equal( elem.nodeName.toLowerCase(), "em", "leading newlines" );
- elem = jQuery("
", attrObj );
+ elem = jQuery( "
", attrObj );
if ( jQuery.fn.width ) {
- assert.equal( elem[0].style.width, "10px", "jQuery() quick setter width");
+ assert.equal( elem[ 0 ].style.width, "10px", "jQuery() quick setter width" );
}
if ( jQuery.fn.offset ) {
- assert.equal( elem[0].style.top, "1px", "jQuery() quick setter offset");
+ assert.equal( elem[ 0 ].style.top, "1px", "jQuery() quick setter offset" );
}
if ( jQuery.fn.css ) {
- assert.equal( elem[0].style.paddingLeft, "1px", "jQuery quick setter css");
- assert.equal( elem[0].style.paddingRight, "1px", "jQuery quick setter css");
+ assert.equal( elem[ 0 ].style.paddingLeft, "1px", "jQuery quick setter css" );
+ assert.equal( elem[ 0 ].style.paddingRight, "1px", "jQuery quick setter css" );
}
if ( jQuery.fn.attr ) {
- assert.equal( elem[0].getAttribute("desired"), "very", "jQuery quick setter attr");
+ assert.equal( elem[ 0 ].getAttribute( "desired" ), "very", "jQuery quick setter attr" );
}
- assert.equal( elem[0].childNodes.length, 1, "jQuery quick setter text");
- assert.equal( elem[0].firstChild.nodeValue, "test", "jQuery quick setter text");
- assert.equal( elem[0].className, "test2", "jQuery() quick setter class");
- assert.equal( elem[0].id, "test3", "jQuery() quick setter id");
+ assert.equal( elem[ 0 ].childNodes.length, 1, "jQuery quick setter text" );
+ assert.equal( elem[ 0 ].firstChild.nodeValue, "test", "jQuery quick setter text" );
+ assert.equal( elem[ 0 ].className, "test2", "jQuery() quick setter class" );
+ assert.equal( elem[ 0 ].id, "test3", "jQuery() quick setter id" );
exec = true;
- elem.trigger("click");
+ elem.trigger( "click" );
// manually clean up detached elements
elem.remove();
for ( i = 0; i < 3; ++i ) {
- elem = jQuery("
");
+ elem = jQuery( "
" );
}
- assert.equal( elem[0].defaultValue, "TEST", "Ensure cached nodes are cloned properly (Bug #6655)" );
+ assert.equal( elem[ 0 ].defaultValue, "TEST", "Ensure cached nodes are cloned properly (Bug #6655)" );
elem = jQuery( "
", {} );
assert.strictEqual( elem[ 0 ].ownerDocument, document,
"Empty attributes object is not interpreted as a document (trac-8950)" );
-});
+} );
-QUnit.test("jQuery(selector, context)", function( assert ) {
- assert.expect(3);
- assert.deepEqual( jQuery("div p", "#qunit-fixture").get(), q("sndp", "en", "sap"), "Basic selector with string as context" );
- assert.deepEqual( jQuery("div p", q("qunit-fixture")[0]).get(), q("sndp", "en", "sap"), "Basic selector with element as context" );
- assert.deepEqual( jQuery("div p", jQuery("#qunit-fixture")).get(), q("sndp", "en", "sap"), "Basic selector with jQuery object as context" );
-});
+QUnit.test( "jQuery(selector, context)", function( assert ) {
+ assert.expect( 3 );
+ assert.deepEqual( jQuery( "div p", "#qunit-fixture" ).get(), q( "sndp", "en", "sap" ), "Basic selector with string as context" );
+ assert.deepEqual( jQuery( "div p", q( "qunit-fixture" )[ 0 ] ).get(), q( "sndp", "en", "sap" ), "Basic selector with element as context" );
+ assert.deepEqual( jQuery( "div p", jQuery( "#qunit-fixture" ) ).get(), q( "sndp", "en", "sap" ), "Basic selector with jQuery object as context" );
+} );
QUnit.test( "globalEval", function( assert ) {
assert.expect( 3 );
- Globals.register("globalEvalTest");
+ Globals.register( "globalEvalTest" );
- jQuery.globalEval("globalEvalTest = 1;");
+ jQuery.globalEval( "globalEvalTest = 1;" );
assert.equal( window.globalEvalTest, 1, "Test variable assignments are global" );
- jQuery.globalEval("var globalEvalTest = 2;");
+ jQuery.globalEval( "var globalEvalTest = 2;" );
assert.equal( window.globalEvalTest, 2, "Test variable declarations are global" );
- jQuery.globalEval("this.globalEvalTest = 3;");
+ jQuery.globalEval( "this.globalEvalTest = 3;" );
assert.equal( window.globalEvalTest, 3, "Test context (this) is the window object" );
-});
+} );
QUnit.test( "globalEval with 'use strict'", function( assert ) {
assert.expect( 1 );
- Globals.register("strictEvalTest");
+ Globals.register( "strictEvalTest" );
- jQuery.globalEval("'use strict'; var strictEvalTest = 1;");
+ jQuery.globalEval( "'use strict'; var strictEvalTest = 1;" );
assert.equal( window.strictEvalTest, 1, "Test variable declarations are global (strict mode)" );
-});
+} );
QUnit.test( "globalEval execution after script injection (#7862)", function( assert ) {
assert.expect( 1 );
@@ -185,41 +185,41 @@ QUnit.test( "globalEval execution after script injection (#7862)", function( ass
now = jQuery.now();
document.body.appendChild( script );
- jQuery.globalEval( "var strictEvalTest = " + jQuery.now() + ";");
+ jQuery.globalEval( "var strictEvalTest = " + jQuery.now() + ";" );
assert.ok( window.strictEvalTest - now < 500, "Code executed synchronously" );
-});
+} );
// This is not run in AMD mode
if ( jQuery.noConflict ) {
- QUnit.test("noConflict", function( assert ) {
- assert.expect(7);
+ QUnit.test( "noConflict", function( assert ) {
+ assert.expect( 7 );
var $$ = jQuery;
assert.strictEqual( jQuery, jQuery.noConflict(), "noConflict returned the jQuery object" );
- assert.strictEqual( window["jQuery"], $$, "Make sure jQuery wasn't touched." );
- assert.strictEqual( window["$"], original$, "Make sure $ was reverted." );
+ assert.strictEqual( window[ "jQuery" ], $$, "Make sure jQuery wasn't touched." );
+ assert.strictEqual( window[ "$" ], original$, "Make sure $ was reverted." );
jQuery = $ = $$;
- assert.strictEqual( jQuery.noConflict(true), $$, "noConflict returned the jQuery object" );
- assert.strictEqual( window["jQuery"], originaljQuery, "Make sure jQuery was reverted." );
- assert.strictEqual( window["$"], original$, "Make sure $ was reverted." );
- assert.ok( $$().pushStack([]), "Make sure that jQuery still works." );
+ assert.strictEqual( jQuery.noConflict( true ), $$, "noConflict returned the jQuery object" );
+ assert.strictEqual( window[ "jQuery" ], originaljQuery, "Make sure jQuery was reverted." );
+ assert.strictEqual( window[ "$" ], original$, "Make sure $ was reverted." );
+ assert.ok( $$().pushStack( [] ), "Make sure that jQuery still works." );
- window["jQuery"] = jQuery = $$;
- });
+ window[ "jQuery" ] = jQuery = $$;
+ } );
}
-QUnit.test("trim", function( assert ) {
- assert.expect(13);
+QUnit.test( "trim", function( assert ) {
+ assert.expect( 13 );
- var nbsp = String.fromCharCode(160);
+ var nbsp = String.fromCharCode( 160 );
- assert.equal( jQuery.trim("hello "), "hello", "trailing space" );
- assert.equal( jQuery.trim(" hello"), "hello", "leading space" );
- assert.equal( jQuery.trim(" hello "), "hello", "space on both sides" );
- assert.equal( jQuery.trim(" " + nbsp + "hello " + nbsp + " "), "hello", " " );
+ assert.equal( jQuery.trim( "hello " ), "hello", "trailing space" );
+ assert.equal( jQuery.trim( " hello" ), "hello", "leading space" );
+ assert.equal( jQuery.trim( " hello " ), "hello", "space on both sides" );
+ assert.equal( jQuery.trim( " " + nbsp + "hello " + nbsp + " " ), "hello", " " );
assert.equal( jQuery.trim(), "", "Nothing in." );
assert.equal( jQuery.trim( undefined ), "", "Undefined" );
@@ -227,88 +227,88 @@ QUnit.test("trim", function( assert ) {
assert.equal( jQuery.trim( 5 ), "5", "Number" );
assert.equal( jQuery.trim( false ), "false", "Boolean" );
- assert.equal( jQuery.trim(" "), "", "space should be trimmed" );
- assert.equal( jQuery.trim("ipad\xA0"), "ipad", "nbsp should be trimmed" );
- assert.equal( jQuery.trim("\uFEFF"), "", "zwsp should be trimmed" );
- assert.equal( jQuery.trim("\uFEFF \xA0! | \uFEFF"), "! |", "leading/trailing should be trimmed" );
-});
+ assert.equal( jQuery.trim( " " ), "", "space should be trimmed" );
+ assert.equal( jQuery.trim( "ipad\xA0" ), "ipad", "nbsp should be trimmed" );
+ assert.equal( jQuery.trim( "\uFEFF" ), "", "zwsp should be trimmed" );
+ assert.equal( jQuery.trim( "\uFEFF \xA0! | \uFEFF" ), "! |", "leading/trailing should be trimmed" );
+} );
-QUnit.test("type", function( assert ) {
+QUnit.test( "type", function( assert ) {
assert.expect( 28 );
- assert.equal( jQuery.type(null), "null", "null" );
- assert.equal( jQuery.type(undefined), "undefined", "undefined" );
- assert.equal( jQuery.type(true), "boolean", "Boolean" );
- assert.equal( jQuery.type(false), "boolean", "Boolean" );
- assert.equal( jQuery.type(Boolean(true)), "boolean", "Boolean" );
- assert.equal( jQuery.type(0), "number", "Number" );
- assert.equal( jQuery.type(1), "number", "Number" );
- assert.equal( jQuery.type(Number(1)), "number", "Number" );
- assert.equal( jQuery.type(""), "string", "String" );
- assert.equal( jQuery.type("a"), "string", "String" );
- assert.equal( jQuery.type(String("a")), "string", "String" );
- assert.equal( jQuery.type({}), "object", "Object" );
- assert.equal( jQuery.type(/foo/), "regexp", "RegExp" );
- assert.equal( jQuery.type(new RegExp("asdf")), "regexp", "RegExp" );
- assert.equal( jQuery.type([1]), "array", "Array" );
- assert.equal( jQuery.type(new Date()), "date", "Date" );
- assert.equal( jQuery.type(new Function("return;")), "function", "Function" );
- assert.equal( jQuery.type(function(){}), "function", "Function" );
- assert.equal( jQuery.type(new Error()), "error", "Error" );
- assert.equal( jQuery.type(window), "object", "Window" );
- assert.equal( jQuery.type(document), "object", "Document" );
- assert.equal( jQuery.type(document.body), "object", "Element" );
- assert.equal( jQuery.type(document.createTextNode("foo")), "object", "TextNode" );
- assert.equal( jQuery.type(document.getElementsByTagName("*")), "object", "NodeList" );
+ assert.equal( jQuery.type( null ), "null", "null" );
+ assert.equal( jQuery.type( undefined ), "undefined", "undefined" );
+ assert.equal( jQuery.type( true ), "boolean", "Boolean" );
+ assert.equal( jQuery.type( false ), "boolean", "Boolean" );
+ assert.equal( jQuery.type( Boolean( true ) ), "boolean", "Boolean" );
+ assert.equal( jQuery.type( 0 ), "number", "Number" );
+ assert.equal( jQuery.type( 1 ), "number", "Number" );
+ assert.equal( jQuery.type( Number( 1 ) ), "number", "Number" );
+ assert.equal( jQuery.type( "" ), "string", "String" );
+ assert.equal( jQuery.type( "a" ), "string", "String" );
+ assert.equal( jQuery.type( String( "a" ) ), "string", "String" );
+ assert.equal( jQuery.type( {} ), "object", "Object" );
+ assert.equal( jQuery.type( /foo/ ), "regexp", "RegExp" );
+ assert.equal( jQuery.type( new RegExp( "asdf" ) ), "regexp", "RegExp" );
+ assert.equal( jQuery.type( [ 1 ] ), "array", "Array" );
+ assert.equal( jQuery.type( new Date() ), "date", "Date" );
+ assert.equal( jQuery.type( new Function( "return;" ) ), "function", "Function" );
+ assert.equal( jQuery.type( function() {} ), "function", "Function" );
+ assert.equal( jQuery.type( new Error() ), "error", "Error" );
+ assert.equal( jQuery.type( window ), "object", "Window" );
+ assert.equal( jQuery.type( document ), "object", "Document" );
+ assert.equal( jQuery.type( document.body ), "object", "Element" );
+ assert.equal( jQuery.type( document.createTextNode( "foo" ) ), "object", "TextNode" );
+ assert.equal( jQuery.type( document.getElementsByTagName( "*" ) ), "object", "NodeList" );
// Avoid Lint complaints
var MyString = String,
MyNumber = Number,
MyBoolean = Boolean,
MyObject = Object;
- assert.equal( jQuery.type(new MyBoolean(true)), "boolean", "Boolean" );
- assert.equal( jQuery.type(new MyNumber(1)), "number", "Number" );
- assert.equal( jQuery.type(new MyString("a")), "string", "String" );
- assert.equal( jQuery.type(new MyObject()), "object", "Object" );
-});
+ assert.equal( jQuery.type( new MyBoolean( true ) ), "boolean", "Boolean" );
+ assert.equal( jQuery.type( new MyNumber( 1 ) ), "number", "Number" );
+ assert.equal( jQuery.type( new MyString( "a" ) ), "string", "String" );
+ assert.equal( jQuery.type( new MyObject() ), "object", "Object" );
+} );
-QUnit.asyncTest("isPlainObject", function( assert ) {
- assert.expect(15);
+QUnit.asyncTest( "isPlainObject", function( assert ) {
+ assert.expect( 15 );
var pass, iframe, doc,
fn = function() {};
// The use case that we want to match
- assert.ok( jQuery.isPlainObject({}), "{}" );
+ assert.ok( jQuery.isPlainObject( {} ), "{}" );
// Not objects shouldn't be matched
- assert.ok( !jQuery.isPlainObject(""), "string" );
- assert.ok( !jQuery.isPlainObject(0) && !jQuery.isPlainObject(1), "number" );
- assert.ok( !jQuery.isPlainObject(true) && !jQuery.isPlainObject(false), "boolean" );
- assert.ok( !jQuery.isPlainObject(null), "null" );
- assert.ok( !jQuery.isPlainObject(undefined), "undefined" );
+ assert.ok( !jQuery.isPlainObject( "" ), "string" );
+ assert.ok( !jQuery.isPlainObject( 0 ) && !jQuery.isPlainObject( 1 ), "number" );
+ assert.ok( !jQuery.isPlainObject( true ) && !jQuery.isPlainObject( false ), "boolean" );
+ assert.ok( !jQuery.isPlainObject( null ), "null" );
+ assert.ok( !jQuery.isPlainObject( undefined ), "undefined" );
// Arrays shouldn't be matched
- assert.ok( !jQuery.isPlainObject([]), "array" );
+ assert.ok( !jQuery.isPlainObject( [] ), "array" );
// Instantiated objects shouldn't be matched
- assert.ok( !jQuery.isPlainObject(new Date()), "new Date" );
+ assert.ok( !jQuery.isPlainObject( new Date() ), "new Date" );
// Functions shouldn't be matched
- assert.ok( !jQuery.isPlainObject(fn), "fn" );
+ assert.ok( !jQuery.isPlainObject( fn ), "fn" );
// Again, instantiated objects shouldn't be matched
- assert.ok( !jQuery.isPlainObject(new fn()), "new fn (no methods)" );
+ assert.ok( !jQuery.isPlainObject( new fn() ), "new fn (no methods)" );
// Makes the function a little more realistic
// (and harder to detect, incidentally)
- fn.prototype["someMethod"] = function(){};
+ fn.prototype[ "someMethod" ] = function() {};
// Again, instantiated objects shouldn't be matched
- assert.ok( !jQuery.isPlainObject(new fn()), "new fn" );
+ assert.ok( !jQuery.isPlainObject( new fn() ), "new fn" );
// DOM Element
- assert.ok( !jQuery.isPlainObject( document.createElement("div") ), "DOM Element" );
+ assert.ok( !jQuery.isPlainObject( document.createElement( "div" ) ), "DOM Element" );
// Window
assert.ok( !jQuery.isPlainObject( window ), "window" );
@@ -321,27 +321,27 @@ QUnit.asyncTest("isPlainObject", function( assert ) {
assert.ok( pass, "Does not throw exceptions on host objects" );
// Objects from other windows should be matched
- Globals.register("iframeDone");
+ Globals.register( "iframeDone" );
window.iframeDone = function( otherObject, detail ) {
window.iframeDone = undefined;
iframe.parentNode.removeChild( iframe );
- assert.ok( jQuery.isPlainObject(new otherObject()), "new otherObject" + ( detail ? " - " + detail : "" ) );
+ assert.ok( jQuery.isPlainObject( new otherObject() ), "new otherObject" + ( detail ? " - " + detail : "" ) );
QUnit.start();
};
try {
- iframe = jQuery("#qunit-fixture")[0].appendChild( document.createElement("iframe") );
+ iframe = jQuery( "#qunit-fixture" )[ 0 ].appendChild( document.createElement( "iframe" ) );
doc = iframe.contentDocument || iframe.contentWindow.document;
doc.open();
- doc.write("");
+ doc.write( "" );
doc.close();
- } catch(e) {
+ } catch ( e ) {
window.iframeDone( Object, "iframes not supported" );
}
-});
+} );
-QUnit.test("isFunction", function( assert ) {
- assert.expect(19);
+QUnit.test( "isFunction", function( assert ) {
+ assert.expect( 19 );
var mystr, myarr, myfunction, fn, obj, nodes, first, input, a;
@@ -353,31 +353,31 @@ QUnit.test("isFunction", function( assert ) {
assert.ok( !jQuery.isFunction( 0 ), "0 Value" );
// Check built-ins
- assert.ok( jQuery.isFunction(String), "String Function("+String+")" );
- assert.ok( jQuery.isFunction(Array), "Array Function("+Array+")" );
- assert.ok( jQuery.isFunction(Object), "Object Function("+Object+")" );
- assert.ok( jQuery.isFunction(Function), "Function Function("+Function+")" );
+ assert.ok( jQuery.isFunction( String ), "String Function(" + String + ")" );
+ assert.ok( jQuery.isFunction( Array ), "Array Function(" + Array + ")" );
+ assert.ok( jQuery.isFunction( Object ), "Object Function(" + Object + ")" );
+ assert.ok( jQuery.isFunction( Function ), "Function Function(" + Function + ")" );
// When stringified, this could be misinterpreted
mystr = "function";
- assert.ok( !jQuery.isFunction(mystr), "Function String" );
+ assert.ok( !jQuery.isFunction( mystr ), "Function String" );
// When stringified, this could be misinterpreted
myarr = [ "function" ];
- assert.ok( !jQuery.isFunction(myarr), "Function Array" );
+ assert.ok( !jQuery.isFunction( myarr ), "Function Array" );
// When stringified, this could be misinterpreted
myfunction = { "function": "test" };
- assert.ok( !jQuery.isFunction(myfunction), "Function Object" );
+ assert.ok( !jQuery.isFunction( myfunction ), "Function Object" );
// Make sure normal functions still work
- fn = function(){};
- assert.ok( jQuery.isFunction(fn), "Normal Function" );
+ fn = function() {};
+ assert.ok( jQuery.isFunction( fn ), "Normal Function" );
- obj = document.createElement("object");
+ obj = document.createElement( "object" );
// Firefox says this is a function
- assert.ok( !jQuery.isFunction(obj), "Object Element" );
+ assert.ok( !jQuery.isFunction( obj ), "Object Element" );
// Since 1.3, this isn't supported (#2968)
//ok( jQuery.isFunction(obj.getAttribute), "getAttribute Function" );
@@ -385,14 +385,14 @@ QUnit.test("isFunction", function( assert ) {
nodes = document.body.childNodes;
// Safari says this is a function
- assert.ok( !jQuery.isFunction(nodes), "childNodes Property" );
+ assert.ok( !jQuery.isFunction( nodes ), "childNodes Property" );
first = document.body.firstChild;
// Normal elements are reported ok everywhere
- assert.ok( !jQuery.isFunction(first), "A normal DOM Element" );
+ assert.ok( !jQuery.isFunction( first ), "A normal DOM Element" );
- input = document.createElement("input");
+ input = document.createElement( "input" );
input.type = "text";
document.body.appendChild( input );
@@ -401,30 +401,30 @@ QUnit.test("isFunction", function( assert ) {
document.body.removeChild( input );
- a = document.createElement("a");
+ a = document.createElement( "a" );
a.href = "some-function";
document.body.appendChild( a );
// This serializes with the word 'function' in it
- assert.ok( !jQuery.isFunction(a), "Anchor Element" );
+ assert.ok( !jQuery.isFunction( a ), "Anchor Element" );
document.body.removeChild( a );
// Recursive function calls have lengths and array-like properties
- function callme(callback){
- function fn(response){
- callback(response);
+ function callme( callback ) {
+ function fn( response ) {
+ callback( response );
}
- assert.ok( jQuery.isFunction(fn), "Recursive Function Call" );
+ assert.ok( jQuery.isFunction( fn ), "Recursive Function Call" );
- fn({ some: "data" });
+ fn( { some: "data" } );
}
- callme(function(){
- callme(function(){});
- });
-});
+ callme( function() {
+ callme( function() {} );
+ } );
+} );
QUnit.test( "isNumeric", function( assert ) {
assert.expect( 38 );
@@ -473,345 +473,349 @@ QUnit.test( "isNumeric", function( assert ) {
assert.equal( t( {} ), false, "Empty object" );
assert.equal( t( [] ), false, "Empty array" );
assert.equal( t( [ 42 ] ), false, "Array with one number" );
- assert.equal( t( function(){} ), false, "Instance of a function" );
+ assert.equal( t( function() {} ), false, "Instance of a function" );
assert.equal( t( new Date() ), false, "Instance of a Date" );
-});
+} );
-QUnit.test("isXMLDoc - HTML", function( assert ) {
- assert.expect(4);
+QUnit.test( "isXMLDoc - HTML", function( assert ) {
+ assert.expect( 4 );
assert.ok( !jQuery.isXMLDoc( document ), "HTML document" );
assert.ok( !jQuery.isXMLDoc( document.documentElement ), "HTML documentElement" );
assert.ok( !jQuery.isXMLDoc( document.body ), "HTML Body Element" );
var body,
- iframe = document.createElement("iframe");
+ iframe = document.createElement( "iframe" );
document.body.appendChild( iframe );
try {
- body = jQuery(iframe).contents()[0];
+ body = jQuery( iframe ).contents()[ 0 ];
try {
assert.ok( !jQuery.isXMLDoc( body ), "Iframe body element" );
- } catch(e) {
+ } catch ( e ) {
assert.ok( false, "Iframe body element exception" );
}
- } catch(e) {
+ } catch ( e ) {
assert.ok( true, "Iframe body element - iframe not working correctly" );
}
document.body.removeChild( iframe );
-});
+} );
-QUnit.test("XSS via location.hash", function( assert ) {
- assert.expect(1);
+QUnit.test( "XSS via location.hash", function( assert ) {
+ assert.expect( 1 );
QUnit.stop();
- jQuery["_check9521"] = function(x){
+ jQuery[ "_check9521" ] = function( x ) {
assert.ok( x, "script called from #id-like selector with inline handler" );
- jQuery("#check9521").remove();
- delete jQuery["_check9521"];
+ jQuery( "#check9521" ).remove();
+ delete jQuery[ "_check9521" ];
QUnit.start();
};
try {
- // This throws an error because it's processed like an id
- jQuery( "#
" ).appendTo("#qunit-fixture");
- } catch (err) {
- jQuery["_check9521"](true);
- }
-});
-QUnit.test("isXMLDoc - XML", function( assert ) {
- assert.expect(3);
+ // This throws an error because it's processed like an id
+ jQuery( "#
" ).appendTo( "#qunit-fixture" );
+ } catch ( err ) {
+ jQuery[ "_check9521" ]( true );
+ }
+} );
+
+QUnit.test( "isXMLDoc - XML", function( assert ) {
+ assert.expect( 3 );
var xml = createDashboardXML();
assert.ok( jQuery.isXMLDoc( xml ), "XML document" );
assert.ok( jQuery.isXMLDoc( xml.documentElement ), "XML documentElement" );
- assert.ok( jQuery.isXMLDoc( jQuery("tab", xml)[0] ), "XML Tab Element" );
-});
+ assert.ok( jQuery.isXMLDoc( jQuery( "tab", xml )[ 0 ] ), "XML Tab Element" );
+} );
-QUnit.test("isWindow", function( assert ) {
+QUnit.test( "isWindow", function( assert ) {
assert.expect( 14 );
- assert.ok( jQuery.isWindow(window), "window" );
- assert.ok( jQuery.isWindow(document.getElementsByTagName("iframe")[0].contentWindow), "iframe.contentWindow" );
+ assert.ok( jQuery.isWindow( window ), "window" );
+ assert.ok( jQuery.isWindow( document.getElementsByTagName( "iframe" )[ 0 ].contentWindow ), "iframe.contentWindow" );
assert.ok( !jQuery.isWindow(), "empty" );
- assert.ok( !jQuery.isWindow(null), "null" );
- assert.ok( !jQuery.isWindow(undefined), "undefined" );
- assert.ok( !jQuery.isWindow(document), "document" );
- assert.ok( !jQuery.isWindow(document.documentElement), "documentElement" );
- assert.ok( !jQuery.isWindow(""), "string" );
- assert.ok( !jQuery.isWindow(1), "number" );
- assert.ok( !jQuery.isWindow(true), "boolean" );
- assert.ok( !jQuery.isWindow({}), "object" );
- assert.ok( !jQuery.isWindow({ setInterval: function(){} }), "fake window" );
- assert.ok( !jQuery.isWindow(/window/), "regexp" );
- assert.ok( !jQuery.isWindow(function(){}), "function" );
-});
+ assert.ok( !jQuery.isWindow( null ), "null" );
+ assert.ok( !jQuery.isWindow( undefined ), "undefined" );
+ assert.ok( !jQuery.isWindow( document ), "document" );
+ assert.ok( !jQuery.isWindow( document.documentElement ), "documentElement" );
+ assert.ok( !jQuery.isWindow( "" ), "string" );
+ assert.ok( !jQuery.isWindow( 1 ), "number" );
+ assert.ok( !jQuery.isWindow( true ), "boolean" );
+ assert.ok( !jQuery.isWindow( {} ), "object" );
+ assert.ok( !jQuery.isWindow( { setInterval: function() {} } ), "fake window" );
+ assert.ok( !jQuery.isWindow( /window/ ), "regexp" );
+ assert.ok( !jQuery.isWindow( function() {} ), "function" );
+} );
-QUnit.test("jQuery('html')", function( assert ) {
+QUnit.test( "jQuery('html')", function( assert ) {
assert.expect( 18 );
var s, div, j;
- jQuery["foo"] = false;
- s = jQuery("")[0];
+ jQuery[ "foo" ] = false;
+ s = jQuery( "" )[ 0 ];
assert.ok( s, "Creating a script" );
- assert.ok( !jQuery["foo"], "Make sure the script wasn't executed prematurely" );
- jQuery("body").append("");
- assert.ok( jQuery["foo"], "Executing a scripts contents in the right context" );
+ assert.ok( !jQuery[ "foo" ], "Make sure the script wasn't executed prematurely" );
+ jQuery( "body" ).append( "" );
+ assert.ok( jQuery[ "foo" ], "Executing a scripts contents in the right context" );
// Test multi-line HTML
- div = jQuery("
\r\nsome text\n
some p
\nmore text\r\n
")[0];
+ div = jQuery( "
\r\nsome text\n
some p
\nmore text\r\n
" )[ 0 ];
assert.equal( div.nodeName.toUpperCase(), "DIV", "Make sure we're getting a div." );
assert.equal( div.firstChild.nodeType, 3, "Text node." );
assert.equal( div.lastChild.nodeType, 3, "Text node." );
- assert.equal( div.childNodes[1].nodeType, 1, "Paragraph." );
- assert.equal( div.childNodes[1].firstChild.nodeType, 3, "Paragraph text." );
+ assert.equal( div.childNodes[ 1 ].nodeType, 1, "Paragraph." );
+ assert.equal( div.childNodes[ 1 ].firstChild.nodeType, 3, "Paragraph text." );
- assert.ok( jQuery("
")[0], "Creating a link" );
+ assert.ok( jQuery( "
" )[ 0 ], "Creating a link" );
- assert.ok( !jQuery("")[0].parentNode, "Create a script" );
+ assert.ok( !jQuery( "" )[ 0 ].parentNode, "Create a script" );
- assert.ok( jQuery("
").attr("type", "hidden"), "Create an input and set the type." );
+ assert.ok( jQuery( "
" ).attr( "type", "hidden" ), "Create an input and set the type." );
- j = jQuery("
hi there ");
+ j = jQuery( "
hi there " );
assert.ok( j.length >= 2, "Check node,textnode,comment creation (some browsers delete comments)" );
- assert.ok( !jQuery("
test ")[0].selected, "Make sure that options are auto-selected #2050" );
+ assert.ok( !jQuery( "
test " )[ 0 ].selected, "Make sure that options are auto-selected #2050" );
- assert.ok( jQuery("
")[0], "Create a div with closing tag." );
- assert.ok( jQuery("
")[0], "Create a table with closing tag." );
+ assert.ok( jQuery( "
" )[ 0 ], "Create a div with closing tag." );
+ assert.ok( jQuery( "
" )[ 0 ], "Create a table with closing tag." );
assert.equal( jQuery( "element[attribute='
']" ).length, 0,
"When html is within brackets, do not recognize as html." );
+
//equal( jQuery( "element[attribute=
]" ).length, 0,
// "When html is within brackets, do not recognize as html." );
assert.equal( jQuery( "element:not(
)" ).length, 0,
"When html is within parens, do not recognize as html." );
assert.equal( jQuery( "\\
" ).length, 0, "Ignore escaped html characters" );
-});
+} );
-QUnit.test("jQuery(tag-hyphenated elements) gh-1987", function( assert ) {
+QUnit.test( "jQuery(tag-hyphenated elements) gh-1987", function( assert ) {
assert.expect( 17 );
- jQuery.each( "thead tbody tfoot colgroup caption tr th td".split(" "), function( i, name ) {
- var j = jQuery("<" + name + "-d>");
- assert.ok( j[0], "Create a tag-hyphenated elements" );
- assert.ok( jQuery.nodeName(j[0], name.toUpperCase() + "-D"), "Tag-hyphenated element has expected node name" );
- });
+ jQuery.each( "thead tbody tfoot colgroup caption tr th td".split( " " ), function( i, name ) {
+ var j = jQuery( "<" + name + "-d>" );
+ assert.ok( j[ 0 ], "Create a tag-hyphenated elements" );
+ assert.ok( jQuery.nodeName( j[ 0 ], name.toUpperCase() + "-D" ), "Tag-hyphenated element has expected node name" );
+ } );
- var j = jQuery("very very very very large html string ",
- html = [""];
+ html = [ "" ];
for ( i = 0; i < 30000; i += 1 ) {
- html[html.length] = li;
+ html[ html.length ] = li;
}
- html[html.length] = " ";
- html = jQuery(html.join(""))[0];
- assert.equal( html.nodeName.toLowerCase(), "ul");
- assert.equal( html.firstChild.nodeName.toLowerCase(), "li");
+ html[ html.length ] = " ";
+ html = jQuery( html.join( "" ) )[ 0 ];
+ assert.equal( html.nodeName.toLowerCase(), "ul" );
+ assert.equal( html.firstChild.nodeName.toLowerCase(), "li" );
assert.equal( html.childNodes.length, 30000 );
-});
+} );
-QUnit.test("jQuery('html', context)", function( assert ) {
- assert.expect(1);
+QUnit.test( "jQuery('html', context)", function( assert ) {
+ assert.expect( 1 );
- var $div = jQuery("
")[0],
- $span = jQuery("
" )[ 0 ],
+ $span = jQuery( "
", document.getElementById("form") );
- }, "Passing an element as the context raises an exception (context should be a document)");
+ assert.throws( function() {
+ jQuery.parseHTML( "
", document.getElementById( "form" ) );
+ }, "Passing an element as the context raises an exception (context should be a document)" );
- nodes = jQuery.parseHTML( jQuery("body")[0].innerHTML );
+ nodes = jQuery.parseHTML( jQuery( "body" )[ 0 ].innerHTML );
assert.ok( nodes.length > 4, "Parse a large html string" );
assert.equal( jQuery.type( nodes ), "array", "parseHTML returns an array rather than a nodelist" );
html = "";
assert.equal( jQuery.parseHTML( html ).length, 0, "Ignore scripts by default" );
- assert.equal( jQuery.parseHTML( html, true )[0].nodeName.toLowerCase(), "script", "Preserve scripts when requested" );
+ assert.equal( jQuery.parseHTML( html, true )[ 0 ].nodeName.toLowerCase(), "script", "Preserve scripts when requested" );
html += "
";
- assert.equal( jQuery.parseHTML( html )[0].nodeName.toLowerCase(), "div", "Preserve non-script nodes" );
- assert.equal( jQuery.parseHTML( html, true )[0].nodeName.toLowerCase(), "script", "Preserve script position");
+ assert.equal( jQuery.parseHTML( html )[ 0 ].nodeName.toLowerCase(), "div", "Preserve non-script nodes" );
+ assert.equal( jQuery.parseHTML( html, true )[ 0 ].nodeName.toLowerCase(), "script", "Preserve script position" );
- assert.equal( jQuery.parseHTML("text")[0].nodeType, 3, "Parsing text returns a text node" );
- assert.equal( jQuery.parseHTML( "\t
" )[0].nodeValue, "\t", "Preserve leading whitespace" );
+ assert.equal( jQuery.parseHTML( "text" )[ 0 ].nodeType, 3, "Parsing text returns a text node" );
+ assert.equal( jQuery.parseHTML( "\t
" )[ 0 ].nodeValue, "\t", "Preserve leading whitespace" );
- assert.equal( jQuery.parseHTML("
")[0].nodeType, 3, "Leading spaces are treated as text nodes (#11290)" );
+ assert.equal( jQuery.parseHTML( "
" )[ 0 ].nodeType, 3, "Leading spaces are treated as text nodes (#11290)" );
html = jQuery.parseHTML( "test div
" );
assert.equal( html[ 0 ].parentNode.nodeType, 11, "parentNode should be documentFragment" );
assert.equal( html[ 0 ].innerHTML, "test div", "Content should be preserved" );
- assert.equal( jQuery.parseHTML("").length, 1, "Incorrect html-strings should not break anything" );
- assert.equal( jQuery.parseHTML(" ")[ 1 ].parentNode.nodeType, 11,
+ assert.equal( jQuery.parseHTML( "" ).length, 1, "Incorrect html-strings should not break anything" );
+ assert.equal( jQuery.parseHTML( " " )[ 1 ].parentNode.nodeType, 11,
"parentNode should be documentFragment for wrapMap (variable in manipulation module) elements too" );
- assert.ok( jQuery.parseHTML("<#if> This is a test.
This is a test.
present in document" );
assert.strictEqual( tmp.childNodes[ 0 ].nodeValue, "well-formed", " text is as expected" );
- } catch (e) {
+ } catch ( e ) {
assert.strictEqual( e, undefined, "unexpected error" );
}
try {
xml = jQuery.parseXML( " Not a <well-formed xml string
" );
assert.ok( false, "invalid xml not detected" );
- } catch( e ) {
+ } catch ( e ) {
assert.strictEqual( e.message, "Invalid XML: Not a <well-formed xml string
", "invalid xml detected" );
}
try {
@@ -1510,12 +1516,12 @@ QUnit.test("jQuery.parseXML", function( assert ){
assert.strictEqual( xml, null, "null string => null document" );
xml = jQuery.parseXML( true );
assert.strictEqual( xml, null, "non-string => null document" );
- } catch( e ) {
+ } catch ( e ) {
assert.ok( false, "empty input throws exception" );
}
-});
+} );
-QUnit.test("jQuery.camelCase()", function( assert ) {
+QUnit.test( "jQuery.camelCase()", function( assert ) {
var tests = {
"foo-bar": "fooBar",
@@ -1527,12 +1533,12 @@ QUnit.test("jQuery.camelCase()", function( assert ) {
"-ms-take": "msTake"
};
- assert.expect(7);
+ assert.expect( 7 );
jQuery.each( tests, function( key, val ) {
assert.equal( jQuery.camelCase( key ), val, "Converts: " + key + " => " + val );
- });
-});
+ } );
+} );
testIframeWithCallback(
"Conditional compilation compatibility (#13274)",
diff --git a/test/unit/css.js b/test/unit/css.js
index c28afd6fa..f91c50940 100644
--- a/test/unit/css.js
+++ b/test/unit/css.js
@@ -1,85 +1,85 @@
if ( jQuery.css ) {
-QUnit.module("css", { teardown: moduleTeardown });
+QUnit.module( "css", { teardown: moduleTeardown } );
-QUnit.test("css(String|Hash)", function( assert ) {
+QUnit.test( "css(String|Hash)", function( assert ) {
assert.expect( 42 );
- assert.equal( jQuery("#qunit-fixture").css("display"), "block", "Check for css property \"display\"" );
+ assert.equal( jQuery( "#qunit-fixture" ).css( "display" ), "block", "Check for css property \"display\"" );
var $child, div, div2, width, height, child, prctval, checkval, old;
- $child = jQuery("#nothiddendivchild").css({ "width": "20%", "height": "20%" });
- assert.notEqual( $child.css("width"), "20px", "Retrieving a width percentage on the child of a hidden div returns percentage" );
- assert.notEqual( $child.css("height"), "20px", "Retrieving a height percentage on the child of a hidden div returns percentage" );
+ $child = jQuery( "#nothiddendivchild" ).css( { "width": "20%", "height": "20%" } );
+ assert.notEqual( $child.css( "width" ), "20px", "Retrieving a width percentage on the child of a hidden div returns percentage" );
+ assert.notEqual( $child.css( "height" ), "20px", "Retrieving a height percentage on the child of a hidden div returns percentage" );
div = jQuery( "
" );
// These should be "auto" (or some better value)
// temporarily provide "0px" for backwards compat
- assert.equal( div.css("width"), "0px", "Width on disconnected node." );
- assert.equal( div.css("height"), "0px", "Height on disconnected node." );
+ assert.equal( div.css( "width" ), "0px", "Width on disconnected node." );
+ assert.equal( div.css( "height" ), "0px", "Height on disconnected node." );
- div.css({ "width": 4, "height": 4 });
+ div.css( { "width": 4, "height": 4 } );
- assert.equal( div.css("width"), "4px", "Width on disconnected node." );
- assert.equal( div.css("height"), "4px", "Height on disconnected node." );
+ assert.equal( div.css( "width" ), "4px", "Width on disconnected node." );
+ assert.equal( div.css( "height" ), "4px", "Height on disconnected node." );
- div2 = jQuery( "").appendTo("body");
+ div2 = jQuery( "" ).appendTo( "body" );
- assert.equal( div2.find("input").css("height"), "20px", "Height on hidden input." );
- assert.equal( div2.find("textarea").css("height"), "20px", "Height on hidden textarea." );
- assert.equal( div2.find("div").css("height"), "20px", "Height on hidden div." );
+ assert.equal( div2.find( "input" ).css( "height" ), "20px", "Height on hidden input." );
+ assert.equal( div2.find( "textarea" ).css( "height" ), "20px", "Height on hidden textarea." );
+ assert.equal( div2.find( "div" ).css( "height" ), "20px", "Height on hidden div." );
div2.remove();
// handle negative numbers by setting to zero #11604
- jQuery("#nothiddendiv").css( {"width": 1, "height": 1} );
+ jQuery( "#nothiddendiv" ).css( { "width": 1, "height": 1 } );
- width = parseFloat(jQuery("#nothiddendiv").css("width"));
- height = parseFloat(jQuery("#nothiddendiv").css("height"));
- jQuery("#nothiddendiv").css({ "overflow":"hidden", "width": -1, "height": -1 });
- assert.equal( parseFloat(jQuery("#nothiddendiv").css("width")), 0, "Test negative width set to 0");
- assert.equal( parseFloat(jQuery("#nothiddendiv").css("height")), 0, "Test negative height set to 0");
+ width = parseFloat( jQuery( "#nothiddendiv" ).css( "width" ) );
+ height = parseFloat( jQuery( "#nothiddendiv" ).css( "height" ) );
+ jQuery( "#nothiddendiv" ).css( { "overflow":"hidden", "width": -1, "height": -1 } );
+ assert.equal( parseFloat( jQuery( "#nothiddendiv" ).css( "width" ) ), 0, "Test negative width set to 0" );
+ assert.equal( parseFloat( jQuery( "#nothiddendiv" ).css( "height" ) ), 0, "Test negative height set to 0" );
- assert.equal( jQuery("
").css("display"), "none", "Styles on disconnected nodes");
+ assert.equal( jQuery( "
" ).css( "display" ), "none", "Styles on disconnected nodes" );
- jQuery("#floatTest").css({"float": "right"});
- assert.equal( jQuery("#floatTest").css("float"), "right", "Modified CSS float using \"float\": Assert float is right");
- jQuery("#floatTest").css({"font-size": "30px"});
- assert.equal( jQuery("#floatTest").css("font-size"), "30px", "Modified CSS font-size: Assert font-size is 30px");
- jQuery.each("0,0.25,0.5,0.75,1".split(","), function(i, n) {
- jQuery("#foo").css({"opacity": n});
+ jQuery( "#floatTest" ).css( { "float": "right" } );
+ assert.equal( jQuery( "#floatTest" ).css( "float" ), "right", "Modified CSS float using \"float\": Assert float is right" );
+ jQuery( "#floatTest" ).css( { "font-size": "30px" } );
+ assert.equal( jQuery( "#floatTest" ).css( "font-size" ), "30px", "Modified CSS font-size: Assert font-size is 30px" );
+ jQuery.each( "0,0.25,0.5,0.75,1".split( "," ), function( i, n ) {
+ jQuery( "#foo" ).css( { "opacity": n } );
- assert.equal( jQuery("#foo").css("opacity"), parseFloat(n), "Assert opacity is " + parseFloat(n) + " as a String" );
- jQuery("#foo").css({"opacity": parseFloat(n)});
- assert.equal( jQuery("#foo").css("opacity"), parseFloat(n), "Assert opacity is " + parseFloat(n) + " as a Number" );
- });
- jQuery("#foo").css({"opacity": ""});
- assert.equal( jQuery("#foo").css("opacity"), "1", "Assert opacity is 1 when set to an empty String" );
+ assert.equal( jQuery( "#foo" ).css( "opacity" ), parseFloat( n ), "Assert opacity is " + parseFloat( n ) + " as a String" );
+ jQuery( "#foo" ).css( { "opacity": parseFloat( n ) } );
+ assert.equal( jQuery( "#foo" ).css( "opacity" ), parseFloat( n ), "Assert opacity is " + parseFloat( n ) + " as a Number" );
+ } );
+ jQuery( "#foo" ).css( { "opacity": "" } );
+ assert.equal( jQuery( "#foo" ).css( "opacity" ), "1", "Assert opacity is 1 when set to an empty String" );
- assert.equal( jQuery("#empty").css("opacity"), "0", "Assert opacity is accessible via filter property set in stylesheet in IE" );
- jQuery("#empty").css({ "opacity": "1" });
- assert.equal( jQuery("#empty").css("opacity"), "1", "Assert opacity is taken from style attribute when set vs stylesheet in IE with filters" );
+ assert.equal( jQuery( "#empty" ).css( "opacity" ), "0", "Assert opacity is accessible via filter property set in stylesheet in IE" );
+ jQuery( "#empty" ).css( { "opacity": "1" } );
+ assert.equal( jQuery( "#empty" ).css( "opacity" ), "1", "Assert opacity is taken from style attribute when set vs stylesheet in IE with filters" );
- div = jQuery("#nothiddendiv");
- child = jQuery("#nothiddendivchild");
+ div = jQuery( "#nothiddendiv" );
+ child = jQuery( "#nothiddendivchild" );
- assert.equal( parseInt(div.css("fontSize"), 10), 16, "Verify fontSize px set." );
- assert.equal( parseInt(div.css("font-size"), 10), 16, "Verify fontSize px set." );
- assert.equal( parseInt(child.css("fontSize"), 10), 16, "Verify fontSize px set." );
- assert.equal( parseInt(child.css("font-size"), 10), 16, "Verify fontSize px set." );
+ assert.equal( parseInt( div.css( "fontSize" ), 10 ), 16, "Verify fontSize px set." );
+ assert.equal( parseInt( div.css( "font-size" ), 10 ), 16, "Verify fontSize px set." );
+ assert.equal( parseInt( child.css( "fontSize" ), 10 ), 16, "Verify fontSize px set." );
+ assert.equal( parseInt( child.css( "font-size" ), 10 ), 16, "Verify fontSize px set." );
- child.css("height", "100%");
- assert.equal( child[0].style.height, "100%", "Make sure the height is being set correctly." );
+ child.css( "height", "100%" );
+ assert.equal( child[ 0 ].style.height, "100%", "Make sure the height is being set correctly." );
- child.attr("class", "em");
- assert.equal( parseInt(child.css("fontSize"), 10), 32, "Verify fontSize em set." );
+ child.attr( "class", "em" );
+ assert.equal( parseInt( child.css( "fontSize" ), 10 ), 32, "Verify fontSize em set." );
// Have to verify this as the result depends upon the browser's CSS
// support for font-size percentages
- child.attr("class", "prct");
- prctval = parseInt(child.css("fontSize"), 10);
+ child.attr( "class", "prct" );
+ prctval = parseInt( child.css( "fontSize" ), 10 );
checkval = 0;
if ( prctval === 16 || prctval === 24 ) {
checkval = prctval;
@@ -87,123 +87,123 @@ QUnit.test("css(String|Hash)", function( assert ) {
assert.equal( prctval, checkval, "Verify fontSize % set." );
- assert.equal( typeof child.css("width"), "string", "Make sure that a string width is returned from css('width')." );
+ assert.equal( typeof child.css( "width" ), "string", "Make sure that a string width is returned from css('width')." );
- old = child[0].style.height;
+ old = child[ 0 ].style.height;
// Test NaN
- child.css("height", parseFloat("zoo"));
- assert.equal( child[0].style.height, old, "Make sure height isn't changed on NaN." );
+ child.css( "height", parseFloat( "zoo" ) );
+ assert.equal( child[ 0 ].style.height, old, "Make sure height isn't changed on NaN." );
// Test null
- child.css("height", null);
- assert.equal( child[0].style.height, old, "Make sure height isn't changed on null." );
+ child.css( "height", null );
+ assert.equal( child[ 0 ].style.height, old, "Make sure height isn't changed on null." );
- old = child[0].style.fontSize;
+ old = child[ 0 ].style.fontSize;
// Test NaN
- child.css("font-size", parseFloat("zoo"));
- assert.equal( child[0].style.fontSize, old, "Make sure font-size isn't changed on NaN." );
+ child.css( "font-size", parseFloat( "zoo" ) );
+ assert.equal( child[ 0 ].style.fontSize, old, "Make sure font-size isn't changed on NaN." );
// Test null
- child.css("font-size", null);
- assert.equal( child[0].style.fontSize, old, "Make sure font-size isn't changed on null." );
+ child.css( "font-size", null );
+ assert.equal( child[ 0 ].style.fontSize, old, "Make sure font-size isn't changed on null." );
assert.strictEqual( child.css( "x-fake" ), undefined, "Make sure undefined is returned from css(nonexistent)." );
- div = jQuery( "
" ).css({ position: "absolute", "z-index": 1000 }).appendTo( "#qunit-fixture" );
+ div = jQuery( "
" ).css( { position: "absolute", "z-index": 1000 } ).appendTo( "#qunit-fixture" );
assert.strictEqual( div.css( "z-index" ), "1000",
"Make sure that a string z-index is returned from css('z-index') (#14432)." );
-});
+} );
QUnit.test( "css() explicit and relative values", function( assert ) {
assert.expect( 29 );
- var $elem = jQuery("#nothiddendiv");
+ var $elem = jQuery( "#nothiddendiv" );
- $elem.css({ "width": 1, "height": 1, "paddingLeft": "1px", "opacity": 1 });
- assert.equal( $elem.css("width"), "1px", "Initial css set or width/height works (hash)" );
- assert.equal( $elem.css("paddingLeft"), "1px", "Initial css set of paddingLeft works (hash)" );
- assert.equal( $elem.css("opacity"), "1", "Initial css set of opacity works (hash)" );
+ $elem.css( { "width": 1, "height": 1, "paddingLeft": "1px", "opacity": 1 } );
+ assert.equal( $elem.css( "width" ), "1px", "Initial css set or width/height works (hash)" );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "Initial css set of paddingLeft works (hash)" );
+ assert.equal( $elem.css( "opacity" ), "1", "Initial css set of opacity works (hash)" );
- $elem.css({ width: "+=9" });
- assert.equal( $elem.css("width"), "10px", "'+=9' on width (hash)" );
+ $elem.css( { width: "+=9" } );
+ assert.equal( $elem.css( "width" ), "10px", "'+=9' on width (hash)" );
- $elem.css({ "width": "-=9" });
- assert.equal( $elem.css("width"), "1px", "'-=9' on width (hash)" );
+ $elem.css( { "width": "-=9" } );
+ assert.equal( $elem.css( "width" ), "1px", "'-=9' on width (hash)" );
- $elem.css({ "width": "+=9px" });
- assert.equal( $elem.css("width"), "10px", "'+=9px' on width (hash)" );
+ $elem.css( { "width": "+=9px" } );
+ assert.equal( $elem.css( "width" ), "10px", "'+=9px' on width (hash)" );
- $elem.css({ "width": "-=9px" });
- assert.equal( $elem.css("width"), "1px", "'-=9px' on width (hash)" );
+ $elem.css( { "width": "-=9px" } );
+ assert.equal( $elem.css( "width" ), "1px", "'-=9px' on width (hash)" );
$elem.css( "width", "+=9" );
- assert.equal( $elem.css("width"), "10px", "'+=9' on width (params)" );
+ assert.equal( $elem.css( "width" ), "10px", "'+=9' on width (params)" );
$elem.css( "width", "-=9" ) ;
- assert.equal( $elem.css("width"), "1px", "'-=9' on width (params)" );
+ assert.equal( $elem.css( "width" ), "1px", "'-=9' on width (params)" );
$elem.css( "width", "+=9px" );
- assert.equal( $elem.css("width"), "10px", "'+=9px' on width (params)" );
+ assert.equal( $elem.css( "width" ), "10px", "'+=9px' on width (params)" );
$elem.css( "width", "-=9px" );
- assert.equal( $elem.css("width"), "1px", "'-=9px' on width (params)" );
+ assert.equal( $elem.css( "width" ), "1px", "'-=9px' on width (params)" );
$elem.css( "width", "-=-9px" );
- assert.equal( $elem.css("width"), "10px", "'-=-9px' on width (params)" );
+ assert.equal( $elem.css( "width" ), "10px", "'-=-9px' on width (params)" );
$elem.css( "width", "+=-9px" );
- assert.equal( $elem.css("width"), "1px", "'+=-9px' on width (params)" );
+ assert.equal( $elem.css( "width" ), "1px", "'+=-9px' on width (params)" );
- $elem.css({ "paddingLeft": "+=4" });
- assert.equal( $elem.css("paddingLeft"), "5px", "'+=4' on paddingLeft (hash)" );
+ $elem.css( { "paddingLeft": "+=4" } );
+ assert.equal( $elem.css( "paddingLeft" ), "5px", "'+=4' on paddingLeft (hash)" );
- $elem.css({ "paddingLeft": "-=4" });
- assert.equal( $elem.css("paddingLeft"), "1px", "'-=4' on paddingLeft (hash)" );
+ $elem.css( { "paddingLeft": "-=4" } );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "'-=4' on paddingLeft (hash)" );
- $elem.css({ "paddingLeft": "+=4px" });
- assert.equal( $elem.css("paddingLeft"), "5px", "'+=4px' on paddingLeft (hash)" );
+ $elem.css( { "paddingLeft": "+=4px" } );
+ assert.equal( $elem.css( "paddingLeft" ), "5px", "'+=4px' on paddingLeft (hash)" );
- $elem.css({ "paddingLeft": "-=4px" });
- assert.equal( $elem.css("paddingLeft"), "1px", "'-=4px' on paddingLeft (hash)" );
+ $elem.css( { "paddingLeft": "-=4px" } );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "'-=4px' on paddingLeft (hash)" );
- $elem.css({ "padding-left": "+=4" });
- assert.equal( $elem.css("paddingLeft"), "5px", "'+=4' on padding-left (hash)" );
+ $elem.css( { "padding-left": "+=4" } );
+ assert.equal( $elem.css( "paddingLeft" ), "5px", "'+=4' on padding-left (hash)" );
- $elem.css({ "padding-left": "-=4" });
- assert.equal( $elem.css("paddingLeft"), "1px", "'-=4' on padding-left (hash)" );
+ $elem.css( { "padding-left": "-=4" } );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "'-=4' on padding-left (hash)" );
- $elem.css({ "padding-left": "+=4px" });
- assert.equal( $elem.css("paddingLeft"), "5px", "'+=4px' on padding-left (hash)" );
+ $elem.css( { "padding-left": "+=4px" } );
+ assert.equal( $elem.css( "paddingLeft" ), "5px", "'+=4px' on padding-left (hash)" );
- $elem.css({ "padding-left": "-=4px" });
- assert.equal( $elem.css("paddingLeft"), "1px", "'-=4px' on padding-left (hash)" );
+ $elem.css( { "padding-left": "-=4px" } );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "'-=4px' on padding-left (hash)" );
$elem.css( "paddingLeft", "+=4" );
- assert.equal( $elem.css("paddingLeft"), "5px", "'+=4' on paddingLeft (params)" );
+ assert.equal( $elem.css( "paddingLeft" ), "5px", "'+=4' on paddingLeft (params)" );
$elem.css( "paddingLeft", "-=4" );
- assert.equal( $elem.css("paddingLeft"), "1px", "'-=4' on paddingLeft (params)" );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "'-=4' on paddingLeft (params)" );
$elem.css( "padding-left", "+=4px" );
- assert.equal( $elem.css("paddingLeft"), "5px", "'+=4px' on padding-left (params)" );
+ assert.equal( $elem.css( "paddingLeft" ), "5px", "'+=4px' on padding-left (params)" );
$elem.css( "padding-left", "-=4px" );
- assert.equal( $elem.css("paddingLeft"), "1px", "'-=4px' on padding-left (params)" );
+ assert.equal( $elem.css( "paddingLeft" ), "1px", "'-=4px' on padding-left (params)" );
- $elem.css({ "opacity": "-=0.5" });
- assert.equal( $elem.css("opacity"), "0.5", "'-=0.5' on opacity (hash)" );
+ $elem.css( { "opacity": "-=0.5" } );
+ assert.equal( $elem.css( "opacity" ), "0.5", "'-=0.5' on opacity (hash)" );
- $elem.css({ "opacity": "+=0.5" });
- assert.equal( $elem.css("opacity"), "1", "'+=0.5' on opacity (hash)" );
+ $elem.css( { "opacity": "+=0.5" } );
+ assert.equal( $elem.css( "opacity" ), "1", "'+=0.5' on opacity (hash)" );
$elem.css( "opacity", "-=0.5" );
- assert.equal( $elem.css("opacity"), "0.5", "'-=0.5' on opacity (params)" );
+ assert.equal( $elem.css( "opacity" ), "0.5", "'-=0.5' on opacity (params)" );
$elem.css( "opacity", "+=0.5" );
- assert.equal( $elem.css("opacity"), "1", "'+=0.5' on opacity (params)" );
-});
+ assert.equal( $elem.css( "opacity" ), "1", "'+=0.5' on opacity (params)" );
+} );
QUnit.test( "css() non-px relative values (gh-1711)", function( assert ) {
assert.expect( 17 );
@@ -240,12 +240,12 @@ QUnit.test( "css() non-px relative values (gh-1711)", function( assert ) {
"pc": parseFloat( $child.css( prop, "100pc" ).css( prop ) ) / 100,
"cm": parseFloat( $child.css( prop, "100cm" ).css( prop ) ) / 100,
"mm": parseFloat( $child.css( prop, "100mm" ).css( prop ) ) / 100,
- "%" : parseFloat( $child.css( prop, "100%" ).css( prop ) ) / 100
+ "%": parseFloat( $child.css( prop, "100%" ).css( prop ) ) / 100
};
};
- jQuery( "#nothiddendiv" ).css({ height: 1, padding: 0, width: 400 });
- $child.css({ height: 1, padding: 0 });
+ jQuery( "#nothiddendiv" ).css( { height: 1, padding: 0, width: 400 } );
+ $child.css( { height: 1, padding: 0 } );
getUnits( "width" );
cssCurrent = parseFloat( $child.css( "width", "50%" ).css( "width" ) );
@@ -269,44 +269,44 @@ QUnit.test( "css() non-px relative values (gh-1711)", function( assert ) {
add( "lineHeight", 1, "cm" );
add( "lineHeight", -20, "mm" );
add( "lineHeight", 50, "%" );
-});
+} );
-QUnit.test("css(String, Object)", function( assert ) {
+QUnit.test( "css(String, Object)", function( assert ) {
assert.expect( 19 );
var j, div, display, ret, success;
- jQuery("#floatTest").css("float", "left");
- assert.equal( jQuery("#floatTest").css("float"), "left", "Modified CSS float using \"float\": Assert float is left");
- jQuery("#floatTest").css("font-size", "20px");
- assert.equal( jQuery("#floatTest").css("font-size"), "20px", "Modified CSS font-size: Assert font-size is 20px");
+ jQuery( "#floatTest" ).css( "float", "left" );
+ assert.equal( jQuery( "#floatTest" ).css( "float" ), "left", "Modified CSS float using \"float\": Assert float is left" );
+ jQuery( "#floatTest" ).css( "font-size", "20px" );
+ assert.equal( jQuery( "#floatTest" ).css( "font-size" ), "20px", "Modified CSS font-size: Assert font-size is 20px" );
- jQuery.each("0,0.25,0.5,0.75,1".split(","), function(i, n) {
- jQuery("#foo").css("opacity", n);
- assert.equal( jQuery("#foo").css("opacity"), parseFloat(n), "Assert opacity is " + parseFloat(n) + " as a String" );
- jQuery("#foo").css("opacity", parseFloat(n));
- assert.equal( jQuery("#foo").css("opacity"), parseFloat(n), "Assert opacity is " + parseFloat(n) + " as a Number" );
- });
- jQuery("#foo").css("opacity", "");
- assert.equal( jQuery("#foo").css("opacity"), "1", "Assert opacity is 1 when set to an empty String" );
+ jQuery.each( "0,0.25,0.5,0.75,1".split( "," ), function( i, n ) {
+ jQuery( "#foo" ).css( "opacity", n );
+ assert.equal( jQuery( "#foo" ).css( "opacity" ), parseFloat( n ), "Assert opacity is " + parseFloat( n ) + " as a String" );
+ jQuery( "#foo" ).css( "opacity", parseFloat( n ) );
+ assert.equal( jQuery( "#foo" ).css( "opacity" ), parseFloat( n ), "Assert opacity is " + parseFloat( n ) + " as a Number" );
+ } );
+ jQuery( "#foo" ).css( "opacity", "" );
+ assert.equal( jQuery( "#foo" ).css( "opacity" ), "1", "Assert opacity is 1 when set to an empty String" );
// using contents will get comments regular, text, and comment nodes
- j = jQuery("#nonnodes").contents();
- j.css("overflow", "visible");
- assert.equal( j.css("overflow"), "visible", "Check node,textnode,comment css works" );
- assert.equal( jQuery("#t2037 .hidden").css("display"), "none", "Make sure browser thinks it is hidden" );
+ j = jQuery( "#nonnodes" ).contents();
+ j.css( "overflow", "visible" );
+ assert.equal( j.css( "overflow" ), "visible", "Check node,textnode,comment css works" );
+ assert.equal( jQuery( "#t2037 .hidden" ).css( "display" ), "none", "Make sure browser thinks it is hidden" );
- div = jQuery("#nothiddendiv");
- display = div.css("display");
- ret = div.css("display", undefined);
+ div = jQuery( "#nothiddendiv" );
+ display = div.css( "display" );
+ ret = div.css( "display", undefined );
assert.equal( ret, div, "Make sure setting undefined returns the original set." );
- assert.equal( div.css("display"), display, "Make sure that the display wasn't changed." );
+ assert.equal( div.css( "display" ), display, "Make sure that the display wasn't changed." );
success = true;
try {
jQuery( "#foo" ).css( "backgroundColor", "rgba(0, 0, 0, 0.1)" );
}
- catch (e) {
+ catch ( e ) {
success = false;
}
assert.ok( success, "Setting RGBA values does not throw Error (#5509)" );
@@ -314,7 +314,7 @@ QUnit.test("css(String, Object)", function( assert ) {
jQuery( "#foo" ).css( "font", "7px/21px sans-serif" );
assert.strictEqual( jQuery( "#foo" ).css( "line-height" ), "21px",
"Set font shorthand property (#14759)" );
-});
+} );
QUnit.test( "css(String, Object) with negative values", function( assert ) {
assert.expect( 4 );
@@ -329,7 +329,7 @@ QUnit.test( "css(String, Object) with negative values", function( assert ) {
jQuery( "#nothiddendiv" ).css( "left", "-20px" );
assert.equal( jQuery( "#nothiddendiv" ).css( "top" ), "-20px", "Ensure negative top values work." );
assert.equal( jQuery( "#nothiddendiv" ).css( "left" ), "-20px", "Ensure negative left values work." );
-});
+} );
QUnit.test( "css(Array)", function( assert ) {
assert.expect( 2 );
@@ -341,179 +341,179 @@ QUnit.test( "css(Array)", function( assert ) {
expectedSingle = {
"width": "16px"
},
- elem = jQuery("
").appendTo("#qunit-fixture");
+ elem = jQuery( "
" ).appendTo( "#qunit-fixture" );
- assert.deepEqual( elem.css( expectedMany ).css([ "overflow", "width" ]), expectedMany, "Getting multiple element array" );
- assert.deepEqual( elem.css( expectedSingle ).css([ "width" ]), expectedSingle, "Getting single element array" );
-});
+ assert.deepEqual( elem.css( expectedMany ).css( [ "overflow", "width" ] ), expectedMany, "Getting multiple element array" );
+ assert.deepEqual( elem.css( expectedSingle ).css( [ "width" ] ), expectedSingle, "Getting single element array" );
+} );
-QUnit.test("css(String, Function)", function( assert ) {
- assert.expect(3);
+QUnit.test( "css(String, Function)", function( assert ) {
+ assert.expect( 3 );
var index,
- sizes = ["10px", "20px", "30px"];
+ sizes = [ "10px", "20px", "30px" ];
- jQuery("
" +
+ jQuery( "
")
- .appendTo("body");
+ "
" +
+ jQuery( "
")
- .appendTo("body");
+ "
" +
+ jQuery( "
")
- .appendTo("body");
+ "
" +
+ jQuery( "
")
- .appendTo("body");
+ "
").hide();
- assert.equal( div.css("display"), "none", "Detached div hidden" );
- div.appendTo("#qunit-fixture").show();
- assert.equal( div.css("display"), "block", "Initially-detached div after show()" );
+ div = jQuery( "
" ).hide();
+ assert.equal( div.css( "display" ), "none", "Detached div hidden" );
+ div.appendTo( "#qunit-fixture" ).show();
+ assert.equal( div.css( "display" ), "block", "Initially-detached div after show()" );
-});
+} );
-QUnit.test("show();", function( assert ) {
+QUnit.test( "show();", function( assert ) {
assert.expect( 18 );
var hiddendiv, div, pass, old, test;
- hiddendiv = jQuery("div.hidden");
+ hiddendiv = jQuery( "div.hidden" );
- assert.equal(jQuery.css( hiddendiv[0], "display"), "none", "hiddendiv is display: none");
+ assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "none", "hiddendiv is display: none" );
- hiddendiv.css("display", "block");
- assert.equal(jQuery.css( hiddendiv[0], "display"), "block", "hiddendiv is display: block");
+ hiddendiv.css( "display", "block" );
+ assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "block", "hiddendiv is display: block" );
hiddendiv.show();
- assert.equal(jQuery.css( hiddendiv[0], "display"), "block", "hiddendiv is display: block");
+ assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "block", "hiddendiv is display: block" );
- hiddendiv.css("display","");
+ hiddendiv.css( "display", "" );
pass = true;
- div = jQuery("#qunit-fixture div");
- div.show().each(function(){
+ div = jQuery( "#qunit-fixture div" );
+ div.show().each( function() {
if ( this.style.display === "none" ) {
pass = false;
}
- });
+ } );
assert.ok( pass, "Show" );
jQuery(
@@ -524,138 +524,138 @@ QUnit.test("show();", function( assert ) {
"
"
).appendTo( "#qunit-fixture" ).find( "*" ).css( "display", "none" );
- old = jQuery("#test-table").show().css("display") !== "table";
- jQuery("#test-table").remove();
+ old = jQuery( "#test-table" ).show().css( "display" ) !== "table";
+ jQuery( "#test-table" ).remove();
test = {
- "div" : "block",
- "p" : "block",
- "a" : "inline",
- "code" : "inline",
- "pre" : "block",
- "span" : "inline",
- "table" : old ? "block" : "table",
- "thead" : old ? "block" : "table-header-group",
- "tbody" : old ? "block" : "table-row-group",
- "tr" : old ? "block" : "table-row",
- "th" : old ? "block" : "table-cell",
- "td" : old ? "block" : "table-cell",
- "ul" : "block",
- "li" : old ? "block" : "list-item"
+ "div": "block",
+ "p": "block",
+ "a": "inline",
+ "code": "inline",
+ "pre": "block",
+ "span": "inline",
+ "table": old ? "block" : "table",
+ "thead": old ? "block" : "table-header-group",
+ "tbody": old ? "block" : "table-row-group",
+ "tr": old ? "block" : "table-row",
+ "th": old ? "block" : "table-cell",
+ "td": old ? "block" : "table-cell",
+ "ul": "block",
+ "li": old ? "block" : "list-item"
};
- jQuery.each(test, function(selector, expected) {
- var elem = jQuery(selector, "#show-tests").show();
- assert.equal( elem.css("display"), expected, "Show using correct display type for " + selector );
- });
+ jQuery.each( test, function( selector, expected ) {
+ var elem = jQuery( selector, "#show-tests" ).show();
+ assert.equal( elem.css( "display" ), expected, "Show using correct display type for " + selector );
+ } );
// Make sure that showing or hiding a text node doesn't cause an error
- jQuery("
test
text
test ").show().remove();
- jQuery("
test
text
test ").hide().remove();
-});
+ jQuery( "
test
text
test " ).show().remove();
+ jQuery( "
test
text
test " ).hide().remove();
+} );
-QUnit.test( "show() resolves correct default display for detached nodes", function( assert ){
+QUnit.test( "show() resolves correct default display for detached nodes", function( assert ) {
assert.expect( 16 );
var div, span, tr;
- div = jQuery("
");
- div.show().appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "none",
+ div = jQuery( "
" );
+ div.show().appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "none",
"A shown-while-detached div can be hidden by the CSS cascade" );
- div = jQuery("
").children("div");
- div.show().appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "none",
+ div = jQuery( "
" ).children( "div" );
+ div.show().appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "none",
"A shown-while-detached div inside a visible div can be hidden by the CSS cascade" );
- span = jQuery("
");
- span.show().appendTo("#qunit-fixture");
- assert.equal( span.css("display"), "none",
+ span = jQuery( "
" );
+ span.show().appendTo( "#qunit-fixture" );
+ assert.equal( span.css( "display" ), "none",
"A shown-while-detached span can be hidden by the CSS cascade" );
- div = jQuery("div.hidden");
+ div = jQuery( "div.hidden" );
div.detach().show();
assert.ok( !div[ 0 ].style.display,
"show() does not update inline style of a cascade-hidden-before-detach div" );
- div.appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "none",
+ div.appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "none",
"A shown-while-detached cascade-hidden div is hidden after attachment" );
div.remove();
- span = jQuery("
");
- span.appendTo("#qunit-fixture").detach().show().appendTo("#qunit-fixture");
- assert.equal( span.css("display"), "none",
+ span = jQuery( "
" );
+ span.appendTo( "#qunit-fixture" ).detach().show().appendTo( "#qunit-fixture" );
+ assert.equal( span.css( "display" ), "none",
"A shown-while-detached cascade-hidden span is hidden after attachment" );
span.remove();
- div = jQuery( document.createElement("div") );
- div.show().appendTo("#qunit-fixture");
+ div = jQuery( document.createElement( "div" ) );
+ div.show().appendTo( "#qunit-fixture" );
assert.ok( !div[ 0 ].style.display, "A shown-while-detached div has no inline style" );
- assert.equal( div.css("display"), "block",
+ assert.equal( div.css( "display" ), "block",
"A shown-while-detached div has default display after attachment" );
div.remove();
- div = jQuery("
");
+ div = jQuery( "
" );
div.show();
assert.equal( div[ 0 ].style.display, "",
"show() updates inline style of a detached inline-hidden div" );
- div.appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "block",
+ div.appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "block",
"A shown-while-detached inline-hidden div has default display after attachment" );
- div = jQuery("
").children("div");
- div.show().appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "block",
+ div = jQuery( "
" ).children( "div" );
+ div.show().appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "block",
"A shown-while-detached inline-hidden div inside a visible div has default display " +
"after attachment" );
- span = jQuery("
");
+ span = jQuery( "
" );
span.show();
assert.equal( span[ 0 ].style.display, "",
"show() updates inline style of a detached inline-hidden span" );
- span.appendTo("#qunit-fixture");
- assert.equal( span.css("display"), "inline",
+ span.appendTo( "#qunit-fixture" );
+ assert.equal( span.css( "display" ), "inline",
"A shown-while-detached inline-hidden span has default display after attachment" );
- div = jQuery("
");
- div.show().appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "inline",
+ div = jQuery( "
" );
+ div.show().appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "inline",
"show() does not update inline style of a detached inline-visible div" );
div.remove();
- tr = jQuery("
");
- jQuery("#table").append( tr );
+ tr = jQuery( "
" );
+ jQuery( "#table" ).append( tr );
tr.detach().hide().show();
assert.ok( !tr[ 0 ].style.display, "Not-hidden detached tr elements have no inline style" );
tr.remove();
- span = jQuery("
").hide().show();
+ span = jQuery( "
" ).hide().show();
assert.ok( !span[ 0 ].style.display, "Not-hidden detached span elements have no inline style" );
span.remove();
-});
+} );
-QUnit.test("toggle()", function( assert ) {
- assert.expect(9);
+QUnit.test( "toggle()", function( assert ) {
+ assert.expect( 9 );
var div, oldHide,
- x = jQuery("#foo");
+ x = jQuery( "#foo" );
- assert.ok( x.is(":visible"), "is visible" );
+ assert.ok( x.is( ":visible" ), "is visible" );
x.toggle();
- assert.ok( x.is(":hidden"), "is hidden" );
+ assert.ok( x.is( ":hidden" ), "is hidden" );
x.toggle();
- assert.ok( x.is(":visible"), "is visible again" );
+ assert.ok( x.is( ":visible" ), "is visible again" );
- x.toggle(true);
- assert.ok( x.is(":visible"), "is visible" );
- x.toggle(false);
- assert.ok( x.is(":hidden"), "is hidden" );
- x.toggle(true);
- assert.ok( x.is(":visible"), "is visible again" );
+ x.toggle( true );
+ assert.ok( x.is( ":visible" ), "is visible" );
+ x.toggle( false );
+ assert.ok( x.is( ":hidden" ), "is hidden" );
+ x.toggle( true );
+ assert.ok( x.is( ":visible" ), "is visible again" );
- div = jQuery("
").appendTo("#qunit-fixture");
- x = div.find("div");
+ div = jQuery( "
" ).appendTo( "#qunit-fixture" );
+ x = div.find( "div" );
assert.strictEqual( x.toggle().css( "display" ), "none", "is hidden" );
assert.strictEqual( x.toggle().css( "display" ), "block", "is visible" );
@@ -667,103 +667,104 @@ QUnit.test("toggle()", function( assert ) {
};
x.toggle( name === "show" );
jQuery.fn.hide = oldHide;
-});
+} );
-QUnit.test("hide hidden elements (bug #7141)", function( assert ) {
- assert.expect(3);
+QUnit.test( "hide hidden elements (bug #7141)", function( assert ) {
+ assert.expect( 3 );
- var div = jQuery("
").appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "none", "Element is hidden by default" );
+ var div = jQuery( "
" ).appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "none", "Element is hidden by default" );
div.hide();
- assert.ok( !jQuery._data(div, "olddisplay"), "olddisplay is undefined after hiding an already-hidden element" );
+ assert.ok( !jQuery._data( div, "olddisplay" ), "olddisplay is undefined after hiding an already-hidden element" );
div.show();
- assert.equal( div.css("display"), "block", "Show a double-hidden element" );
+ assert.equal( div.css( "display" ), "block", "Show a double-hidden element" );
div.remove();
-});
+} );
-QUnit.test("jQuery.css(elem, 'height') doesn't clear radio buttons (bug #1095)", function( assert ) {
- assert.expect(4);
+QUnit.test( "jQuery.css(elem, 'height') doesn't clear radio buttons (bug #1095)", function( assert ) {
+ assert.expect( 4 );
- var $checkedtest = jQuery("#checkedtest");
- jQuery.css($checkedtest[0], "height");
+ var $checkedtest = jQuery( "#checkedtest" );
+ jQuery.css( $checkedtest[ 0 ], "height" );
- assert.ok( jQuery("input[type='radio']", $checkedtest).first().attr("checked"), "Check first radio still checked." );
- assert.ok( !jQuery("input[type='radio']", $checkedtest).last().attr("checked"), "Check last radio still NOT checked." );
- assert.ok( jQuery("input[type='checkbox']", $checkedtest).first().attr("checked"), "Check first checkbox still checked." );
- assert.ok( !jQuery("input[type='checkbox']", $checkedtest).last().attr("checked"), "Check last checkbox still NOT checked." );
-});
+ assert.ok( jQuery( "input[type='radio']", $checkedtest ).first().attr( "checked" ), "Check first radio still checked." );
+ assert.ok( !jQuery( "input[type='radio']", $checkedtest ).last().attr( "checked" ), "Check last radio still NOT checked." );
+ assert.ok( jQuery( "input[type='checkbox']", $checkedtest ).first().attr( "checked" ), "Check first checkbox still checked." );
+ assert.ok( !jQuery( "input[type='checkbox']", $checkedtest ).last().attr( "checked" ), "Check last checkbox still NOT checked." );
+} );
-QUnit.test("internal ref to elem.runtimeStyle (bug #7608)", function( assert ) {
- assert.expect(1);
+QUnit.test( "internal ref to elem.runtimeStyle (bug #7608)", function( assert ) {
+ assert.expect( 1 );
var result = true;
try {
- jQuery("#foo").css( { "width": "0%" } ).css("width");
- } catch (e) {
+ jQuery( "#foo" ).css( { "width": "0%" } ).css( "width" );
+ } catch ( e ) {
result = false;
}
assert.ok( result, "elem.runtimeStyle does not throw exception" );
-});
+} );
-QUnit.test("marginRight computed style (bug #3333)", function( assert ) {
- assert.expect(1);
+QUnit.test( "marginRight computed style (bug #3333)", function( assert ) {
+ assert.expect( 1 );
- var $div = jQuery("#foo");
- $div.css({
+ var $div = jQuery( "#foo" );
+ $div.css( {
"width": "1px",
"marginRight": 0
- });
+ } );
- assert.equal($div.css("marginRight"), "0px", "marginRight correctly calculated with a width and display block");
-});
+ assert.equal( $div.css( "marginRight" ), "0px", "marginRight correctly calculated with a width and display block" );
+} );
-QUnit.test("box model properties incorrectly returning % instead of px, see #10639 and #12088", function( assert ) {
+QUnit.test( "box model properties incorrectly returning % instead of px, see #10639 and #12088", function( assert ) {
assert.expect( 2 );
- var container = jQuery("
").width( 400 ).appendTo("#qunit-fixture"),
- el = jQuery("
").css({ "width": "50%", "marginRight": "50%" }).appendTo( container ),
- el2 = jQuery("
").css({ "width": "50%", "minWidth": "300px", "marginLeft": "25%" }).appendTo( container );
+ var container = jQuery( "
" ).width( 400 ).appendTo( "#qunit-fixture" ),
+ el = jQuery( "
" ).css( { "width": "50%", "marginRight": "50%" } ).appendTo( container ),
+ el2 = jQuery( "
" ).css( { "width": "50%", "minWidth": "300px", "marginLeft": "25%" } ).appendTo( container );
- assert.equal( el.css("marginRight"), "200px", "css('marginRight') returning % instead of px, see #10639" );
- assert.equal( el2.css("marginLeft"), "100px", "css('marginLeft') returning incorrect pixel value, see #12088" );
-});
+ assert.equal( el.css( "marginRight" ), "200px", "css('marginRight') returning % instead of px, see #10639" );
+ assert.equal( el2.css( "marginLeft" ), "100px", "css('marginLeft') returning incorrect pixel value, see #12088" );
+} );
-QUnit.test("jQuery.cssProps behavior, (bug #8402)", function( assert ) {
+QUnit.test( "jQuery.cssProps behavior, (bug #8402)", function( assert ) {
assert.expect( 2 );
- var div = jQuery( "
" ).appendTo(document.body).css({
+ var div = jQuery( "
" ).appendTo( document.body ).css( {
"position": "absolute",
"top": 0,
"left": 10
- });
+ } );
jQuery.cssProps.top = "left";
- assert.equal( div.css("top"), "10px", "the fixed property is used when accessing the computed style");
- div.css("top", "100px");
- assert.equal( div[0].style.left, "100px", "the fixed property is used when setting the style");
+ assert.equal( div.css( "top" ), "10px", "the fixed property is used when accessing the computed style" );
+ div.css( "top", "100px" );
+ assert.equal( div[ 0 ].style.left, "100px", "the fixed property is used when setting the style" );
+
// cleanup jQuery.cssProps
jQuery.cssProps.top = undefined;
-});
+} );
-QUnit.test("widows & orphans #8936", function( assert ) {
+QUnit.test( "widows & orphans #8936", function( assert ) {
- var $p = jQuery("
").appendTo("#qunit-fixture");
+ var $p = jQuery( "
" ).appendTo( "#qunit-fixture" );
assert.expect( 2 );
- $p.css({
+ $p.css( {
"widows": 3,
"orphans": 3
- });
+ } );
- assert.equal( $p.css( "widows" ) || jQuery.style( $p[0], "widows" ), 3, "widows correctly set to 3" );
- assert.equal( $p.css( "orphans" ) || jQuery.style( $p[0], "orphans" ), 3, "orphans correctly set to 3" );
+ assert.equal( $p.css( "widows" ) || jQuery.style( $p[ 0 ], "widows" ), 3, "widows correctly set to 3" );
+ assert.equal( $p.css( "orphans" ) || jQuery.style( $p[ 0 ], "orphans" ), 3, "orphans correctly set to 3" );
$p.remove();
-});
+} );
-QUnit.test("can't get css for disconnected in IE<9, see #10254 and #8388", function( assert ) {
+QUnit.test( "can't get css for disconnected in IE<9, see #10254 and #8388", function( assert ) {
assert.expect( 2 );
var span, div;
@@ -772,9 +773,9 @@ QUnit.test("can't get css for disconnected in IE<9, see #10254 and #8388", funct
div = jQuery( "
" ).css( "top", 10 );
assert.equal( div.css( "top" ), "10px", "can't get top in IE<9, see #8388" );
-});
+} );
-QUnit.test("can't get background-position in IE<9, see #10796", function( assert ) {
+QUnit.test( "can't get background-position in IE<9, see #10796", function( assert ) {
var div = jQuery( "
" ).appendTo( "#qunit-fixture" ),
units = [
"0 0",
@@ -791,29 +792,30 @@ QUnit.test("can't get background-position in IE<9, see #10796", function( assert
assert.expect( l );
- for( ; i < l; i++ ) {
+ for ( ; i < l; i++ ) {
div.css( "background-position", units [ i ] );
assert.ok( div.css( "background-position" ), "can't get background-position in IE<9, see #10796" );
}
-});
+} );
if ( jQuery.fn.offset ) {
- QUnit.test("percentage properties for left and top should be transformed to pixels, see #9505", function( assert ) {
+ QUnit.test( "percentage properties for left and top should be transformed to pixels, see #9505", function( assert ) {
assert.expect( 2 );
- var parent = jQuery("
").appendTo( "#qunit-fixture" ),
- div = jQuery("
").appendTo( parent );
+ var parent = jQuery( "
" ).appendTo( "#qunit-fixture" ),
+ div = jQuery( "
" ).appendTo( parent );
- assert.equal( div.css("top"), "100px", "position properties not transformed to pixels, see #9505" );
- assert.equal( div.css("left"), "100px", "position properties not transformed to pixels, see #9505" );
- });
+ assert.equal( div.css( "top" ), "100px", "position properties not transformed to pixels, see #9505" );
+ assert.equal( div.css( "left" ), "100px", "position properties not transformed to pixels, see #9505" );
+ } );
}
-QUnit.test("Do not append px (#9548, #12990)", function( assert ) {
+QUnit.test( "Do not append px (#9548, #12990)", function( assert ) {
assert.expect( 2 );
- var $div = jQuery("
").appendTo("#qunit-fixture");
+ var $div = jQuery( "
" ).appendTo( "#qunit-fixture" );
$div.css( "fill-opacity", 1 );
+
// Support: Android 2.3 (no support for fill-opacity)
if ( $div.css( "fill-opacity" ) ) {
assert.equal( $div.css( "fill-opacity" ), 1, "Do not append px to 'fill-opacity'" );
@@ -822,25 +824,25 @@ QUnit.test("Do not append px (#9548, #12990)", function( assert ) {
}
$div.css( "column-count", 1 );
- if ( $div.css("column-count") ) {
- assert.equal( $div.css("column-count"), 1, "Do not append px to 'column-count'" );
+ if ( $div.css( "column-count" ) ) {
+ assert.equal( $div.css( "column-count" ), 1, "Do not append px to 'column-count'" );
} else {
assert.ok( true, "No support for column-count CSS property" );
}
-});
+} );
-QUnit.test("css('width') and css('height') should respect box-sizing, see #11004", function( assert ) {
+QUnit.test( "css('width') and css('height') should respect box-sizing, see #11004", function( assert ) {
assert.expect( 4 );
// Support: Android 2.3 (-webkit-box-sizing).
- var el_dis = jQuery("
test
"),
- el = el_dis.clone().appendTo("#qunit-fixture");
+ var el_dis = jQuery( "
test
" ),
+ el = el_dis.clone().appendTo( "#qunit-fixture" );
- assert.equal( el.css("width"), el.css("width", el.css("width")).css("width"), "css('width') is not respecting box-sizing, see #11004");
- assert.equal( el_dis.css("width"), el_dis.css("width", el_dis.css("width")).css("width"), "css('width') is not respecting box-sizing for disconnected element, see #11004");
- assert.equal( el.css("height"), el.css("height", el.css("height")).css("height"), "css('height') is not respecting box-sizing, see #11004");
- assert.equal( el_dis.css("height"), el_dis.css("height", el_dis.css("height")).css("height"), "css('height') is not respecting box-sizing for disconnected element, see #11004");
-});
+ assert.equal( el.css( "width" ), el.css( "width", el.css( "width" ) ).css( "width" ), "css('width') is not respecting box-sizing, see #11004" );
+ assert.equal( el_dis.css( "width" ), el_dis.css( "width", el_dis.css( "width" ) ).css( "width" ), "css('width') is not respecting box-sizing for disconnected element, see #11004" );
+ assert.equal( el.css( "height" ), el.css( "height", el.css( "height" ) ).css( "height" ), "css('height') is not respecting box-sizing, see #11004" );
+ assert.equal( el_dis.css( "height" ), el_dis.css( "height", el_dis.css( "height" ) ).css( "height" ), "css('height') is not respecting box-sizing for disconnected element, see #11004" );
+} );
testIframeWithCallback(
"css('width') should work correctly before document ready (#14084)",
@@ -857,7 +859,7 @@ testIframeWithCallback(
div = document.createElement( "div" );
div.style.width = "3.3px";
qunitFixture.appendChild( div );
- supportsFractionalGBCR = div.getBoundingClientRect().width.toFixed(1) === "3.3";
+ supportsFractionalGBCR = div.getBoundingClientRect().width.toFixed( 1 ) === "3.3";
qunitFixture.removeChild( div );
QUnit.test( "css('width') and css('height') should return fractional values for nodes in the document", function( assert ) {
@@ -896,23 +898,23 @@ testIframeWithCallback(
} );
} )();
-QUnit.test("certain css values of 'normal' should be convertable to a number, see #8627", function( assert ) {
+QUnit.test( "certain css values of 'normal' should be convertable to a number, see #8627", function( assert ) {
expect ( 3 );
- var el = jQuery("
test
").appendTo("#qunit-fixture");
+ var el = jQuery( "
test
" ).appendTo( "#qunit-fixture" );
- assert.ok( jQuery.isNumeric( parseFloat( el.css("letterSpacing") ) ), "css('letterSpacing') not convertable to number, see #8627" );
- assert.ok( jQuery.isNumeric( parseFloat( el.css("fontWeight") ) ), "css('fontWeight') not convertable to number, see #8627" );
+ assert.ok( jQuery.isNumeric( parseFloat( el.css( "letterSpacing" ) ) ), "css('letterSpacing') not convertable to number, see #8627" );
+ assert.ok( jQuery.isNumeric( parseFloat( el.css( "fontWeight" ) ) ), "css('fontWeight') not convertable to number, see #8627" );
assert.equal( typeof el.css( "fontWeight" ), "string", ".css() returns a string" );
-});
+} );
// only run this test in IE9
if ( document.documentMode === 9 ) {
QUnit.test( ".css('filter') returns a string in IE9, see #12537", function( assert ) {
assert.expect( 1 );
- assert.equal( jQuery("
").css("filter"), "progid:DXImageTransform.Microsoft.gradient(startColorstr=#FFFFFF, endColorstr=#ECECEC)", "IE9 returns the correct value from css('filter')." );
- });
+ assert.equal( jQuery( "
" ).css( "filter" ), "progid:DXImageTransform.Microsoft.gradient(startColorstr=#FFFFFF, endColorstr=#ECECEC)", "IE9 returns the correct value from css('filter')." );
+ } );
}
QUnit.test( "cssHooks - expand", function( assert ) {
@@ -920,7 +922,7 @@ QUnit.test( "cssHooks - expand", function( assert ) {
var result,
properties = {
margin: [ "marginTop", "marginRight", "marginBottom", "marginLeft" ],
- borderWidth: [ "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"],
+ borderWidth: [ "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth" ],
padding: [ "paddingTop", "paddingRight", "paddingBottom", "paddingLeft" ]
};
@@ -929,70 +931,70 @@ QUnit.test( "cssHooks - expand", function( assert ) {
expected = {};
jQuery.each( keys, function( _, key ) {
expected[ key ] = 10;
- });
+ } );
result = hook.expand( 10 );
assert.deepEqual( result, expected, property + " expands properly with a number" );
jQuery.each( keys, function( _, key ) {
expected[ key ] = "10px";
- });
+ } );
result = hook.expand( "10px" );
assert.deepEqual( result, expected, property + " expands properly with '10px'" );
- expected[ keys[1] ] = expected[ keys[3] ] = "20px";
+ expected[ keys[ 1 ] ] = expected[ keys[ 3 ] ] = "20px";
result = hook.expand( "10px 20px" );
assert.deepEqual( result, expected, property + " expands properly with '10px 20px'" );
- expected[ keys[2] ] = "30px";
+ expected[ keys[ 2 ] ] = "30px";
result = hook.expand( "10px 20px 30px" );
assert.deepEqual( result, expected, property + " expands properly with '10px 20px 30px'" );
- expected[ keys[3] ] = "40px";
+ expected[ keys[ 3 ] ] = "40px";
result = hook.expand( "10px 20px 30px 40px" );
assert.deepEqual( result, expected, property + " expands properly with '10px 20px 30px 40px'" );
- });
+ } );
-});
+} );
QUnit.test( "css opacity consistency across browsers (#12685)", function( assert ) {
assert.expect( 4 );
var el,
- fixture = jQuery("#qunit-fixture");
+ fixture = jQuery( "#qunit-fixture" );
// Append style element
- jQuery("").appendTo( fixture );
+ jQuery( "" ).appendTo( fixture );
- el = jQuery("
").appendTo(fixture);
+ el = jQuery( "
" ).appendTo( fixture );
- assert.equal( Math.round( el.css("opacity") * 100 ), 10, "opacity from style sheet (filter:alpha with spaces)" );
- el.removeClass("opacityWithSpaces_t12685").addClass("opacityNoSpaces_t12685");
- assert.equal( Math.round( el.css("opacity") * 100 ), 20, "opacity from style sheet (filter:alpha without spaces)" );
+ assert.equal( Math.round( el.css( "opacity" ) * 100 ), 10, "opacity from style sheet (filter:alpha with spaces)" );
+ el.removeClass( "opacityWithSpaces_t12685" ).addClass( "opacityNoSpaces_t12685" );
+ assert.equal( Math.round( el.css( "opacity" ) * 100 ), 20, "opacity from style sheet (filter:alpha without spaces)" );
el.css( "opacity", 0.3 );
- assert.equal( Math.round( el.css("opacity") * 100 ), 30, "override opacity" );
+ assert.equal( Math.round( el.css( "opacity" ) * 100 ), 30, "override opacity" );
el.css( "opacity", "" );
- assert.equal( Math.round( el.css("opacity") * 100 ), 20, "remove opacity override" );
-});
+ assert.equal( Math.round( el.css( "opacity" ) * 100 ), 20, "remove opacity override" );
+} );
QUnit.test( ":visible/:hidden selectors", function( assert ) {
assert.expect( 17 );
var $div, $table, $a;
- assert.ok( jQuery("#nothiddendiv").is(":visible"), "Modifying CSS display: Assert element is visible" );
- jQuery("#nothiddendiv").css({ display: "none" });
- assert.ok( !jQuery("#nothiddendiv").is(":visible"), "Modified CSS display: Assert element is hidden" );
- jQuery("#nothiddendiv").css({ "display": "block" });
- assert.ok( jQuery("#nothiddendiv").is(":visible"), "Modified CSS display: Assert element is visible");
- assert.ok( !jQuery(window).is(":visible"), "Calling is(':visible') on window does not throw an exception (#10267).");
- assert.ok( !jQuery(document).is(":visible"), "Calling is(':visible') on document does not throw an exception (#10267).");
+ assert.ok( jQuery( "#nothiddendiv" ).is( ":visible" ), "Modifying CSS display: Assert element is visible" );
+ jQuery( "#nothiddendiv" ).css( { display: "none" } );
+ assert.ok( !jQuery( "#nothiddendiv" ).is( ":visible" ), "Modified CSS display: Assert element is hidden" );
+ jQuery( "#nothiddendiv" ).css( { "display": "block" } );
+ assert.ok( jQuery( "#nothiddendiv" ).is( ":visible" ), "Modified CSS display: Assert element is visible" );
+ assert.ok( !jQuery( window ).is( ":visible" ), "Calling is(':visible') on window does not throw an exception (#10267)." );
+ assert.ok( !jQuery( document ).is( ":visible" ), "Calling is(':visible') on document does not throw an exception (#10267)." );
- assert.ok( jQuery("#nothiddendiv").is(":visible"), "Modifying CSS display: Assert element is visible");
- jQuery("#nothiddendiv").css("display", "none");
- assert.ok( !jQuery("#nothiddendiv").is(":visible"), "Modified CSS display: Assert element is hidden");
- jQuery("#nothiddendiv").css("display", "block");
- assert.ok( jQuery("#nothiddendiv").is(":visible"), "Modified CSS display: Assert element is visible");
+ assert.ok( jQuery( "#nothiddendiv" ).is( ":visible" ), "Modifying CSS display: Assert element is visible" );
+ jQuery( "#nothiddendiv" ).css( "display", "none" );
+ assert.ok( !jQuery( "#nothiddendiv" ).is( ":visible" ), "Modified CSS display: Assert element is hidden" );
+ jQuery( "#nothiddendiv" ).css( "display", "block" );
+ assert.ok( jQuery( "#nothiddendiv" ).is( ":visible" ), "Modified CSS display: Assert element is visible" );
assert.ok( jQuery( "#siblingspan" ).is( ":visible" ), "Span with no content is visible" );
$div = jQuery( "
" ).appendTo( "#qunit-fixture" );
@@ -1005,19 +1007,19 @@ QUnit.test( ":visible/:hidden selectors", function( assert ) {
// $br = jQuery( "
" ).appendTo( "#qunit-fixture" );
// ok( $br.is( ":visible" ), "br element is visible" );
- $table = jQuery("#table");
- $table.html("
cell cell ");
- assert.equal(jQuery("#table td:visible").length, 1, "hidden cell is not perceived as visible (#4512). Works on table elements");
- $table.css("display", "none").html("
cell cell ");
- assert.equal(jQuery("#table td:visible").length, 0, "hidden cell children not perceived as visible (#4512)");
+ $table = jQuery( "#table" );
+ $table.html( "
cell cell " );
+ assert.equal( jQuery( "#table td:visible" ).length, 1, "hidden cell is not perceived as visible (#4512). Works on table elements" );
+ $table.css( "display", "none" ).html( "
cell cell " );
+ assert.equal( jQuery( "#table td:visible" ).length, 0, "hidden cell children not perceived as visible (#4512)" );
- t( "Is Visible", "#qunit-fixture div:visible:lt(2)", ["foo", "nothiddendiv"] );
+ t( "Is Visible", "#qunit-fixture div:visible:lt(2)", [ "foo", "nothiddendiv" ] );
t( "Is Not Hidden", "#qunit-fixture:hidden", [] );
- t( "Is Hidden", "#form input:hidden", ["hidden1","hidden2"] );
+ t( "Is Hidden", "#form input:hidden", [ "hidden1","hidden2" ] );
$a = jQuery( "
Header " ).appendTo( "#qunit-fixture" );
assert.ok( $a.is( ":visible" ), "Anchor tag with flow content is visible (gh-2227)" );
-});
+} );
QUnit.test( "Keep the last style if the new one isn't recognized by the browser (#14836)", function( assert ) {
assert.expect( 2 );
@@ -1027,56 +1029,59 @@ QUnit.test( "Keep the last style if the new one isn't recognized by the browser
assert.equal( el.css( "position" ), "absolute", "The old style is kept when setting an unrecognized value" );
el = jQuery( "
" ).css( "position", "absolute" ).css( "position", " " );
assert.equal( el.css( "position" ), "absolute", "The old style is kept when setting to a space" );
-});
+} );
QUnit.test( "Reset the style if set to an empty string", function( assert ) {
assert.expect( 1 );
var el = jQuery( "
" ).css( "position", "absolute" ).css( "position", "" );
+
// Some browsers return an empty string; others "static". Both those cases mean the style
// was reset successfully so accept them both.
assert.equal( el.css( "position" ) || "static", "static",
"The style can be reset by setting to an empty string" );
-});
+} );
QUnit.asyncTest( "Clearing a Cloned Element's Style Shouldn't Clear the Original Element's Style (#8908)", 24, function( assert ) {
var baseUrl = document.location.href.replace( /([^\/]*)$/, "" ),
- styles = [{
+ styles = [ {
name: "backgroundAttachment",
- value: ["fixed"],
+ value: [ "fixed" ],
expected: [ "scroll" ]
},{
name: "backgroundColor",
value: [ "rgb(255, 0, 0)", "rgb(255,0,0)", "#ff0000" ],
- expected: ["transparent"]
+ expected: [ "transparent" ]
}, {
+
// Firefox returns auto's value
name: "backgroundImage",
value: [ "url('test.png')", "url(" + baseUrl + "test.png)", "url(\"" + baseUrl + "test.png\")" ],
expected: [ "none", "url(\"http://static.jquery.com/files/rocker/images/logo_jquery_215x53.gif\")" ]
}, {
name: "backgroundPosition",
- value: ["5% 5%"],
+ value: [ "5% 5%" ],
expected: [ "0% 0%", "-1000px 0px", "-1000px 0%" ]
}, {
+
// Firefox returns no-repeat
name: "backgroundRepeat",
- value: ["repeat-y"],
+ value: [ "repeat-y" ],
expected: [ "repeat", "no-repeat" ]
}, {
name: "backgroundClip",
- value: ["padding-box"],
- expected: ["border-box"]
+ value: [ "padding-box" ],
+ expected: [ "border-box" ]
}, {
name: "backgroundOrigin",
- value: ["content-box"],
- expected: ["padding-box"]
+ value: [ "content-box" ],
+ expected: [ "padding-box" ]
}, {
name: "backgroundSize",
- value: ["80px 60px"],
+ value: [ "80px 60px" ],
expected: [ "auto auto" ]
- }];
+ } ];
- jQuery.each(styles, function( index, style ) {
+ jQuery.each( styles, function( index, style ) {
var $clone, $clonedChildren,
$source = jQuery( "#firstp" ),
source = $source[ 0 ],
@@ -1100,7 +1105,7 @@ QUnit.asyncTest( "Clearing a Cloned Element's Style Shouldn't Clear the Original
$clone.css( style.name, "" );
$clonedChildren.css( style.name, "" );
- window.setTimeout(function() {
+ window.setTimeout( function() {
assert.notEqual( $clone.css( style.name ), style.value[ 0 ], "Cloned css was changed" );
assert.ok( jQuery.inArray( $source.css( style.name ) !== -1, style.value ),
@@ -1113,10 +1118,10 @@ QUnit.asyncTest( "Clearing a Cloned Element's Style Shouldn't Clear the Original
"; result: " + $children.css( style.name ) +
"; expected: " + style.value.join( "," ) );
}, 100 );
- });
+ } );
window.setTimeout( start, 1000 );
-});
+} );
QUnit.test( "show() after hide() should always set display to initial value (#14750)", function( assert ) {
assert.expect( 1 );
@@ -1128,13 +1133,13 @@ QUnit.test( "show() after hide() should always set display to initial value (#14
div.css( "display", "inline" ).hide().show().css( "display", "list-item" ).hide().show();
assert.equal( div.css( "display" ), "list-item", "should get last set display value" );
-});
+} );
// Support: IE < 11
// We have to jump through the hoops here in order to test work with "order" CSS property,
// that some browsers do not support. This test is not, strictly speaking, correct,
// but it's the best that we can do.
-(function() {
+( function() {
var style = document.createElement( "div" ).style,
exist = "order" in style || "WebkitOrder" in style;
@@ -1146,9 +1151,9 @@ QUnit.test( "show() after hide() should always set display to initial value (#14
$elem.css( "order", 2 );
assert.equal( $elem.css( "order" ), "2", "2 on order" );
- });
+ } );
}
-})();
+} )();
QUnit.test( "Do not throw on frame elements from css method (#15098)", function( assert ) {
assert.expect( 1 );
@@ -1173,7 +1178,7 @@ QUnit.test( "Do not throw on frame elements from css method (#15098)", function(
} catch ( _ ) {
assert.ok( false, "It did throw" );
}
-});
+} );
( function() {
var vendorPrefixes = [ "Webkit", "Moz", "ms" ];
@@ -1186,6 +1191,7 @@ QUnit.test( "Do not throw on frame elements from css method (#15098)", function(
}
QUnit.test( "Don't default to a cached previously used wrong prefixed name (gh-2015)", function( assert ) {
+
// Note: this test needs a property we know is only supported in a prefixed version
// by at least one of our main supported browsers. This may get out of date so let's
// use -(webkit|moz)-appearance as well as those two are not on a standards track.
diff --git a/test/unit/data.js b/test/unit/data.js
index 21f760473..3a90c0054 100644
--- a/test/unit/data.js
+++ b/test/unit/data.js
@@ -1,13 +1,13 @@
-QUnit.module("data", { teardown: moduleTeardown });
+QUnit.module( "data", { teardown: moduleTeardown } );
-QUnit.test("expando", function( assert ){
- assert.expect(1);
+QUnit.test( "expando", function( assert ) {
+ assert.expect( 1 );
- assert.equal(jQuery.expando !== undefined, true, "jQuery is exposing the expando");
-});
+ assert.equal( jQuery.expando !== undefined, true, "jQuery is exposing the expando" );
+} );
QUnit.test( "jQuery.data & removeData, expected returns", function( assert ) {
- assert.expect(4);
+ assert.expect( 4 );
var elem = document.body;
assert.equal(
@@ -19,7 +19,7 @@ QUnit.test( "jQuery.data & removeData, expected returns", function( assert ) {
"jQuery.data( elem, key ) returns value"
);
assert.deepEqual(
- jQuery.data( elem, { goodnight: "moon" }), { goodnight: "moon" },
+ jQuery.data( elem, { goodnight: "moon" } ), { goodnight: "moon" },
"jQuery.data( elem, obj ) returns obj"
);
assert.equal(
@@ -27,10 +27,10 @@ QUnit.test( "jQuery.data & removeData, expected returns", function( assert ) {
"jQuery.removeData( elem, key, value ) returns undefined"
);
-});
+} );
QUnit.test( "jQuery._data & _removeData, expected returns", function( assert ) {
- assert.expect(4);
+ assert.expect( 4 );
var elem = document.body;
assert.equal(
@@ -42,17 +42,17 @@ QUnit.test( "jQuery._data & _removeData, expected returns", function( assert ) {
"jQuery._data( elem, key ) returns value"
);
assert.deepEqual(
- jQuery._data( elem, { goodnight: "moon" }), { goodnight: "moon" },
+ jQuery._data( elem, { goodnight: "moon" } ), { goodnight: "moon" },
"jQuery._data( elem, obj ) returns obj"
);
assert.equal(
jQuery._removeData( elem, "hello" ), undefined,
"jQuery._removeData( elem, key, value ) returns undefined"
);
-});
+} );
QUnit.test( "jQuery.hasData no side effects", function( assert ) {
- assert.expect(1);
+ assert.expect( 1 );
var obj = {};
jQuery.hasData( obj );
@@ -60,44 +60,44 @@ QUnit.test( "jQuery.hasData no side effects", function( assert ) {
assert.equal( Object.getOwnPropertyNames( obj ).length, 0,
"No data expandos where added when calling jQuery.hasData(o)"
);
-});
+} );
function dataTests( elem, assert ) {
var dataObj, internalDataObj;
- assert.equal( jQuery.data(elem, "foo"), undefined, "No data exists initially" );
- assert.strictEqual( jQuery.hasData(elem), false, "jQuery.hasData agrees no data exists initially" );
+ assert.equal( jQuery.data( elem, "foo" ), undefined, "No data exists initially" );
+ assert.strictEqual( jQuery.hasData( elem ), false, "jQuery.hasData agrees no data exists initially" );
- dataObj = jQuery.data(elem);
+ dataObj = jQuery.data( elem );
assert.equal( typeof dataObj, "object", "Calling data with no args gives us a data object reference" );
- assert.strictEqual( jQuery.data(elem), dataObj, "Calling jQuery.data returns the same data object when called multiple times" );
+ assert.strictEqual( jQuery.data( elem ), dataObj, "Calling jQuery.data returns the same data object when called multiple times" );
- assert.strictEqual( jQuery.hasData(elem), false, "jQuery.hasData agrees no data exists even when an empty data obj exists" );
+ assert.strictEqual( jQuery.hasData( elem ), false, "jQuery.hasData agrees no data exists even when an empty data obj exists" );
- dataObj["foo"] = "bar";
- assert.equal( jQuery.data(elem, "foo"), "bar", "Data is readable by jQuery.data when set directly on a returned data object" );
+ dataObj[ "foo" ] = "bar";
+ assert.equal( jQuery.data( elem, "foo" ), "bar", "Data is readable by jQuery.data when set directly on a returned data object" );
- assert.strictEqual( jQuery.hasData(elem), true, "jQuery.hasData agrees data exists when data exists" );
+ assert.strictEqual( jQuery.hasData( elem ), true, "jQuery.hasData agrees data exists when data exists" );
- jQuery.data(elem, "foo", "baz");
- assert.equal( jQuery.data(elem, "foo"), "baz", "Data can be changed by jQuery.data" );
- assert.equal( dataObj["foo"], "baz", "Changes made through jQuery.data propagate to referenced data object" );
+ jQuery.data( elem, "foo", "baz" );
+ assert.equal( jQuery.data( elem, "foo" ), "baz", "Data can be changed by jQuery.data" );
+ assert.equal( dataObj[ "foo" ], "baz", "Changes made through jQuery.data propagate to referenced data object" );
- jQuery.data(elem, "foo", undefined);
- assert.equal( jQuery.data(elem, "foo"), "baz", "Data is not unset by passing undefined to jQuery.data" );
+ jQuery.data( elem, "foo", undefined );
+ assert.equal( jQuery.data( elem, "foo" ), "baz", "Data is not unset by passing undefined to jQuery.data" );
- jQuery.data(elem, "foo", null);
- assert.strictEqual( jQuery.data(elem, "foo"), null, "Setting null using jQuery.data works OK" );
+ jQuery.data( elem, "foo", null );
+ assert.strictEqual( jQuery.data( elem, "foo" ), null, "Setting null using jQuery.data works OK" );
- jQuery.data(elem, "foo", "foo1");
+ jQuery.data( elem, "foo", "foo1" );
- jQuery.data(elem, { "bar" : "baz", "boom" : "bloz" });
- assert.strictEqual( jQuery.data(elem, "foo"), "foo1", "Passing an object extends the data object instead of replacing it" );
- assert.equal( jQuery.data(elem, "boom"), "bloz", "Extending the data object works" );
+ jQuery.data( elem, { "bar": "baz", "boom": "bloz" } );
+ assert.strictEqual( jQuery.data( elem, "foo" ), "foo1", "Passing an object extends the data object instead of replacing it" );
+ assert.equal( jQuery.data( elem, "boom" ), "bloz", "Extending the data object works" );
- jQuery._data(elem, "foo", "foo2", true);
- assert.equal( jQuery._data(elem, "foo"), "foo2", "Setting internal data works" );
- assert.equal( jQuery.data(elem, "foo"), "foo1", "Setting internal data does not override user data" );
+ jQuery._data( elem, "foo", "foo2", true );
+ assert.equal( jQuery._data( elem, "foo" ), "foo2", "Setting internal data works" );
+ assert.equal( jQuery.data( elem, "foo" ), "foo1", "Setting internal data does not override user data" );
internalDataObj = jQuery._data( elem );
assert.ok( internalDataObj, "Internal data object exists" );
@@ -105,31 +105,31 @@ function dataTests( elem, assert ) {
assert.strictEqual( elem.boom, undefined, "Data is never stored directly on the object" );
- jQuery.removeData(elem, "foo");
- assert.strictEqual( jQuery.data(elem, "foo"), undefined, "jQuery.removeData removes single properties" );
+ jQuery.removeData( elem, "foo" );
+ assert.strictEqual( jQuery.data( elem, "foo" ), undefined, "jQuery.removeData removes single properties" );
- jQuery.removeData(elem);
- assert.strictEqual( jQuery._data(elem), internalDataObj, "jQuery.removeData does not remove internal data if it exists" );
+ jQuery.removeData( elem );
+ assert.strictEqual( jQuery._data( elem ), internalDataObj, "jQuery.removeData does not remove internal data if it exists" );
- jQuery.data(elem, "foo", "foo1");
- jQuery._data(elem, "foo", "foo2");
+ jQuery.data( elem, "foo", "foo1" );
+ jQuery._data( elem, "foo", "foo2" );
- assert.equal( jQuery.data(elem, "foo"), "foo1", "(sanity check) Ensure data is set in user data object" );
- assert.equal( jQuery._data(elem, "foo"), "foo2", "(sanity check) Ensure data is set in internal data object" );
+ assert.equal( jQuery.data( elem, "foo" ), "foo1", "(sanity check) Ensure data is set in user data object" );
+ assert.equal( jQuery._data( elem, "foo" ), "foo2", "(sanity check) Ensure data is set in internal data object" );
- assert.strictEqual( jQuery._data(elem, jQuery.expando), undefined, "Removing the last item in internal data destroys the internal data object" );
+ assert.strictEqual( jQuery._data( elem, jQuery.expando ), undefined, "Removing the last item in internal data destroys the internal data object" );
- jQuery._data(elem, "foo", "foo2");
- assert.equal( jQuery._data(elem, "foo"), "foo2", "(sanity check) Ensure data is set in internal data object" );
+ jQuery._data( elem, "foo", "foo2" );
+ assert.equal( jQuery._data( elem, "foo" ), "foo2", "(sanity check) Ensure data is set in internal data object" );
- jQuery.removeData(elem, "foo");
- assert.equal( jQuery._data(elem, "foo"), "foo2", "(sanity check) jQuery.removeData for user data does not remove internal data" );
+ jQuery.removeData( elem, "foo" );
+ assert.equal( jQuery._data( elem, "foo" ), "foo2", "(sanity check) jQuery.removeData for user data does not remove internal data" );
}
-QUnit.test("jQuery.data(div)", function( assert ) {
+QUnit.test( "jQuery.data(div)", function( assert ) {
assert.expect( 25 );
- var div = document.createElement("div");
+ var div = document.createElement( "div" );
dataTests( div, assert );
@@ -137,15 +137,15 @@ QUnit.test("jQuery.data(div)", function( assert ) {
// assert that nothing else was put in there, and that that
// one stayed there.
QUnit.expectJqData( this, div, "foo" );
-});
+} );
-QUnit.test("jQuery.data({})", function( assert ) {
+QUnit.test( "jQuery.data({})", function( assert ) {
assert.expect( 25 );
dataTests( {}, assert );
-});
+} );
-QUnit.test("jQuery.data(window)", function( assert ) {
+QUnit.test( "jQuery.data(window)", function( assert ) {
assert.expect( 25 );
// remove bound handlers from window object to stop potential false positives caused by fix for #5280 in
@@ -153,66 +153,66 @@ QUnit.test("jQuery.data(window)", function( assert ) {
jQuery( window ).off( "unload" );
dataTests( window, assert );
-});
+} );
-QUnit.test("jQuery.data(document)", function( assert ) {
+QUnit.test( "jQuery.data(document)", function( assert ) {
assert.expect( 25 );
dataTests( document, assert );
QUnit.expectJqData( this, document, "foo" );
-});
+} );
-QUnit.test("jQuery.data(
)", function( assert ) {
+QUnit.test( "jQuery.data()", function( assert ) {
assert.expect( 25 );
- dataTests( document.createElement("embed"), assert );
-});
+ dataTests( document.createElement( "embed" ), assert );
+} );
-QUnit.test("jQuery.data(object/flash)", function( assert ) {
+QUnit.test( "jQuery.data(object/flash)", function( assert ) {
assert.expect( 25 );
- var flash = document.createElement("object");
+ var flash = document.createElement( "object" );
flash.setAttribute( "classid", "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" );
dataTests( flash, assert );
-});
+} );
// attempting to access the data of an undefined jQuery element should be undefined
-QUnit.test("jQuery().data() === undefined (#14101)", function( assert ) {
+QUnit.test( "jQuery().data() === undefined (#14101)", function( assert ) {
assert.expect( 2 );
- assert.strictEqual(jQuery().data(), undefined);
- assert.strictEqual(jQuery().data("key"), undefined);
-});
+ assert.strictEqual( jQuery().data(), undefined );
+ assert.strictEqual( jQuery().data( "key" ), undefined );
+} );
-QUnit.test(".data()", function( assert ) {
- assert.expect(5);
+QUnit.test( ".data()", function( assert ) {
+ assert.expect( 5 );
var div, dataObj, nodiv, obj;
- div = jQuery("#foo");
- assert.strictEqual( div.data("foo"), undefined, "Make sure that missing result is undefined" );
- div.data("test", "success");
+ div = jQuery( "#foo" );
+ assert.strictEqual( div.data( "foo" ), undefined, "Make sure that missing result is undefined" );
+ div.data( "test", "success" );
dataObj = div.data();
- assert.deepEqual( dataObj, {test: "success"}, "data() returns entire data object with expected properties" );
- assert.strictEqual( div.data("foo"), undefined, "Make sure that missing result is still undefined" );
+ assert.deepEqual( dataObj, { test: "success" }, "data() returns entire data object with expected properties" );
+ assert.strictEqual( div.data( "foo" ), undefined, "Make sure that missing result is still undefined" );
- nodiv = jQuery("#unfound");
+ nodiv = jQuery( "#unfound" );
assert.equal( nodiv.data(), null, "data() on empty set returns null" );
obj = { foo: "bar" };
- jQuery(obj).data("foo", "baz");
+ jQuery( obj ).data( "foo", "baz" );
- dataObj = jQuery.extend(true, {}, jQuery(obj).data());
+ dataObj = jQuery.extend( true, {}, jQuery( obj ).data() );
assert.deepEqual( dataObj, { "foo": "baz" }, "Retrieve data object from a wrapped JS object (#7524)" );
-});
+} );
function testDataTypes( $obj, assert ) {
- jQuery.each({
+ jQuery.each( {
"null": null,
"true": true,
"false": false,
@@ -220,90 +220,90 @@ function testDataTypes( $obj, assert ) {
"one": 1,
"empty string": "",
"empty array": [],
- "array": [1],
+ "array": [ 1 ],
"empty object": {},
"object": { foo: "bar" },
"date": new Date(),
"regex": /test/,
"function": function() {}
}, function( type, value ) {
- assert.strictEqual( $obj.data( "test", value ).data("test"), value, "Data set to " + type );
- });
+ assert.strictEqual( $obj.data( "test", value ).data( "test" ), value, "Data set to " + type );
+ } );
}
-QUnit.test("jQuery(Element).data(String, Object).data(String)", function( assert ) {
+QUnit.test( "jQuery(Element).data(String, Object).data(String)", function( assert ) {
assert.expect( 18 );
- var parent = jQuery(""),
+ var parent = jQuery( "" ),
div = parent.children();
- assert.strictEqual( div.data("test"), undefined, "No data exists initially" );
- assert.strictEqual( div.data("test", "success").data("test"), "success", "Data added" );
- assert.strictEqual( div.data("test", "overwritten").data("test"), "overwritten", "Data overwritten" );
- assert.strictEqual( div.data("test", undefined).data("test"), "overwritten", ".data(key,undefined) does nothing but is chainable (#5571)");
- assert.strictEqual( div.data("notexist"), undefined, "No data exists for unset key" );
+ assert.strictEqual( div.data( "test" ), undefined, "No data exists initially" );
+ assert.strictEqual( div.data( "test", "success" ).data( "test" ), "success", "Data added" );
+ assert.strictEqual( div.data( "test", "overwritten" ).data( "test" ), "overwritten", "Data overwritten" );
+ assert.strictEqual( div.data( "test", undefined ).data( "test" ), "overwritten", ".data(key,undefined) does nothing but is chainable (#5571)" );
+ assert.strictEqual( div.data( "notexist" ), undefined, "No data exists for unset key" );
testDataTypes( div, assert );
parent.remove();
-});
+} );
-QUnit.test("jQuery(plain Object).data(String, Object).data(String)", function( assert ) {
+QUnit.test( "jQuery(plain Object).data(String, Object).data(String)", function( assert ) {
assert.expect( 16 );
// #3748
- var $obj = jQuery({ exists: true });
- assert.strictEqual( $obj.data("nothing"), undefined, "Non-existent data returns undefined");
- assert.strictEqual( $obj.data("exists"), undefined, "Object properties are not returned as data" );
+ var $obj = jQuery( { exists: true } );
+ assert.strictEqual( $obj.data( "nothing" ), undefined, "Non-existent data returns undefined" );
+ assert.strictEqual( $obj.data( "exists" ), undefined, "Object properties are not returned as data" );
testDataTypes( $obj, assert );
// Clean up
$obj.removeData();
- assert.deepEqual( $obj[0], { exists: true }, "removeData does not clear the object" );
-});
+ assert.deepEqual( $obj[ 0 ], { exists: true }, "removeData does not clear the object" );
+} );
-QUnit.test(".data(object) does not retain references. #13815", function( assert ) {
+QUnit.test( ".data(object) does not retain references. #13815", function( assert ) {
assert.expect( 2 );
- var $divs = jQuery("
").appendTo("#qunit-fixture");
+ var $divs = jQuery( "
" ).appendTo( "#qunit-fixture" );
- $divs.data({ "type": "foo" });
+ $divs.data( { "type": "foo" } );
$divs.eq( 0 ).data( "type", "bar" );
- assert.equal( $divs.eq( 0 ).data("type"), "bar", "Correct updated value" );
- assert.equal( $divs.eq( 1 ).data("type"), "foo", "Original value retained" );
-});
+ assert.equal( $divs.eq( 0 ).data( "type" ), "bar", "Correct updated value" );
+ assert.equal( $divs.eq( 1 ).data( "type" ), "foo", "Original value retained" );
+} );
-QUnit.test("data-* attributes", function( assert ) {
+QUnit.test( "data-* attributes", function( assert ) {
assert.expect( 46 );
var prop, i, l, metadata, elem,
obj, obj2, check, num, num2,
parseJSON = jQuery.parseJSON,
- div = jQuery(""),
- child = jQuery("
"),
- dummy = jQuery("
");
+ div = jQuery( "
" ),
+ child = jQuery( "
" ),
+ dummy = jQuery( "
" );
- assert.equal( div.data("attr"), undefined, "Check for non-existing data-attr attribute" );
+ assert.equal( div.data( "attr" ), undefined, "Check for non-existing data-attr attribute" );
- div.attr("data-attr", "exists");
- assert.equal( div.data("attr"), "exists", "Check for existing data-attr attribute" );
+ div.attr( "data-attr", "exists" );
+ assert.equal( div.data( "attr" ), "exists", "Check for existing data-attr attribute" );
- div.attr("data-attr", "exists2");
- assert.equal( div.data("attr"), "exists", "Check that updates to data- don't update .data()" );
+ div.attr( "data-attr", "exists2" );
+ assert.equal( div.data( "attr" ), "exists", "Check that updates to data- don't update .data()" );
- div.data("attr", "internal").attr("data-attr", "external");
- assert.equal( div.data("attr"), "internal", "Check for .data('attr') precedence (internal > external data-* attribute)" );
+ div.data( "attr", "internal" ).attr( "data-attr", "external" );
+ assert.equal( div.data( "attr" ), "internal", "Check for .data('attr') precedence (internal > external data-* attribute)" );
div.remove();
- child.appendTo("#qunit-fixture");
- assert.equal( child.data("myobj"), "old data", "Value accessed from data-* attribute");
- assert.equal( child.data("foo-42"), "boosh", "camelCasing does not affect numbers (#1751)" );
+ child.appendTo( "#qunit-fixture" );
+ assert.equal( child.data( "myobj" ), "old data", "Value accessed from data-* attribute" );
+ assert.equal( child.data( "foo-42" ), "boosh", "camelCasing does not affect numbers (#1751)" );
- child.data("myobj", "replaced");
- assert.equal( child.data("myobj"), "replaced", "Original data overwritten");
+ child.data( "myobj", "replaced" );
+ assert.equal( child.data( "myobj" ), "replaced", "Original data overwritten" );
- child.data("ignored", "cache");
- assert.equal( child.data("ignored"), "cache", "Cached data used before DOM data-* fallback");
+ child.data( "ignored", "cache" );
+ assert.equal( child.data( "ignored" ), "cache", "Cached data used before DOM data-* fallback" );
obj = child.data();
obj2 = dummy.data();
@@ -314,8 +314,8 @@ QUnit.test("data-* attributes", function( assert ) {
dummy.remove();
for ( i = 0, l = check.length; i < l; i++ ) {
- assert.ok( obj[ check[i] ], "Make sure data- property exists when calling data-." );
- assert.ok( obj2[ check[i] ], "Make sure data- property exists when calling data-." );
+ assert.ok( obj[ check[ i ] ], "Make sure data- property exists when calling data-." );
+ assert.ok( obj2[ check[ i ] ], "Make sure data- property exists when calling data-." );
}
for ( prop in obj ) {
@@ -330,9 +330,9 @@ QUnit.test("data-* attributes", function( assert ) {
assert.equal( num2, check.length, "Make sure that the right number of properties came through." );
- child.attr("data-other", "newvalue");
+ child.attr( "data-other", "newvalue" );
- assert.equal( child.data("other"), "test", "Make sure value was pulled in properly from a .data()." );
+ assert.equal( child.data( "other" ), "test", "Make sure value was pulled in properly from a .data()." );
// attribute parsing
i = 0;
@@ -342,221 +342,221 @@ QUnit.test("data-* attributes", function( assert ) {
};
child
- .attr("data-true", "true")
- .attr("data-false", "false")
- .attr("data-five", "5")
- .attr("data-point", "5.5")
- .attr("data-pointe", "5.5E3")
- .attr("data-grande", "5.574E9")
- .attr("data-hexadecimal", "0x42")
- .attr("data-pointbad", "5..5")
- .attr("data-pointbad2", "-.")
- .attr("data-bigassnum", "123456789123456789123456789")
- .attr("data-badjson", "{123}")
- .attr("data-badjson2", "[abc]")
- .attr("data-notjson", " {}")
- .attr("data-notjson2", "[] ")
- .attr("data-empty", "")
- .attr("data-space", " ")
- .attr("data-null", "null")
- .attr("data-string", "test");
+ .attr( "data-true", "true" )
+ .attr( "data-false", "false" )
+ .attr( "data-five", "5" )
+ .attr( "data-point", "5.5" )
+ .attr( "data-pointe", "5.5E3" )
+ .attr( "data-grande", "5.574E9" )
+ .attr( "data-hexadecimal", "0x42" )
+ .attr( "data-pointbad", "5..5" )
+ .attr( "data-pointbad2", "-." )
+ .attr( "data-bigassnum", "123456789123456789123456789" )
+ .attr( "data-badjson", "{123}" )
+ .attr( "data-badjson2", "[abc]" )
+ .attr( "data-notjson", " {}" )
+ .attr( "data-notjson2", "[] " )
+ .attr( "data-empty", "" )
+ .attr( "data-space", " " )
+ .attr( "data-null", "null" )
+ .attr( "data-string", "test" );
- assert.strictEqual( child.data("true"), true, "Primitive true read from attribute");
- assert.strictEqual( child.data("false"), false, "Primitive false read from attribute");
- assert.strictEqual( child.data("five"), 5, "Integer read from attribute");
- assert.strictEqual( child.data("point"), 5.5, "Floating-point number read from attribute");
- assert.strictEqual( child.data("pointe"), "5.5E3",
- "Exponential-notation number read from attribute as string");
- assert.strictEqual( child.data("grande"), "5.574E9",
- "Big exponential-notation number read from attribute as string");
- assert.strictEqual( child.data("hexadecimal"), "0x42",
- "Hexadecimal number read from attribute as string");
- assert.strictEqual( child.data("pointbad"), "5..5",
- "Extra-point non-number read from attribute as string");
- assert.strictEqual( child.data("pointbad2"), "-.",
- "No-digit non-number read from attribute as string");
- assert.strictEqual( child.data("bigassnum"), "123456789123456789123456789",
- "Bad bigass number read from attribute as string");
- assert.strictEqual( child.data("badjson"), "{123}", "Bad JSON object read from attribute as string");
- assert.strictEqual( child.data("badjson2"), "[abc]", "Bad JSON array read from attribute as string");
- assert.strictEqual( child.data("notjson"), " {}",
- "JSON object with leading non-JSON read from attribute as string");
- assert.strictEqual( child.data("notjson2"), "[] ",
- "JSON array with trailing non-JSON read from attribute as string");
- assert.strictEqual( child.data("empty"), "", "Empty string read from attribute");
- assert.strictEqual( child.data("space"), " ", "Whitespace string read from attribute");
- assert.strictEqual( child.data("null"), null, "Primitive null read from attribute");
- assert.strictEqual( child.data("string"), "test", "Typical string read from attribute");
+ assert.strictEqual( child.data( "true" ), true, "Primitive true read from attribute" );
+ assert.strictEqual( child.data( "false" ), false, "Primitive false read from attribute" );
+ assert.strictEqual( child.data( "five" ), 5, "Integer read from attribute" );
+ assert.strictEqual( child.data( "point" ), 5.5, "Floating-point number read from attribute" );
+ assert.strictEqual( child.data( "pointe" ), "5.5E3",
+ "Exponential-notation number read from attribute as string" );
+ assert.strictEqual( child.data( "grande" ), "5.574E9",
+ "Big exponential-notation number read from attribute as string" );
+ assert.strictEqual( child.data( "hexadecimal" ), "0x42",
+ "Hexadecimal number read from attribute as string" );
+ assert.strictEqual( child.data( "pointbad" ), "5..5",
+ "Extra-point non-number read from attribute as string" );
+ assert.strictEqual( child.data( "pointbad2" ), "-.",
+ "No-digit non-number read from attribute as string" );
+ assert.strictEqual( child.data( "bigassnum" ), "123456789123456789123456789",
+ "Bad bigass number read from attribute as string" );
+ assert.strictEqual( child.data( "badjson" ), "{123}", "Bad JSON object read from attribute as string" );
+ assert.strictEqual( child.data( "badjson2" ), "[abc]", "Bad JSON array read from attribute as string" );
+ assert.strictEqual( child.data( "notjson" ), " {}",
+ "JSON object with leading non-JSON read from attribute as string" );
+ assert.strictEqual( child.data( "notjson2" ), "[] ",
+ "JSON array with trailing non-JSON read from attribute as string" );
+ assert.strictEqual( child.data( "empty" ), "", "Empty string read from attribute" );
+ assert.strictEqual( child.data( "space" ), " ", "Whitespace string read from attribute" );
+ assert.strictEqual( child.data( "null" ), null, "Primitive null read from attribute" );
+ assert.strictEqual( child.data( "string" ), "test", "Typical string read from attribute" );
assert.equal( i, 2, "Correct number of JSON parse attempts when reading from attributes" );
jQuery.parseJSON = parseJSON;
child.remove();
// tests from metadata plugin
- function testData(index, elem) {
- switch (index) {
+ function testData( index, elem ) {
+ switch ( index ) {
case 0:
- assert.equal(jQuery(elem).data("foo"), "bar", "Check foo property");
- assert.equal(jQuery(elem).data("bar"), "baz", "Check baz property");
+ assert.equal( jQuery( elem ).data( "foo" ), "bar", "Check foo property" );
+ assert.equal( jQuery( elem ).data( "bar" ), "baz", "Check baz property" );
break;
case 1:
- assert.equal(jQuery(elem).data("test"), "bar", "Check test property");
- assert.equal(jQuery(elem).data("bar"), "baz", "Check bar property");
+ assert.equal( jQuery( elem ).data( "test" ), "bar", "Check test property" );
+ assert.equal( jQuery( elem ).data( "bar" ), "baz", "Check bar property" );
break;
case 2:
- assert.equal(jQuery(elem).data("zoooo"), "bar", "Check zoooo property");
- assert.deepEqual(jQuery(elem).data("bar"), {"test":"baz"}, "Check bar property");
+ assert.equal( jQuery( elem ).data( "zoooo" ), "bar", "Check zoooo property" );
+ assert.deepEqual( jQuery( elem ).data( "bar" ), { "test":"baz" }, "Check bar property" );
break;
case 3:
- assert.equal(jQuery(elem).data("number"), true, "Check number property");
- assert.deepEqual(jQuery(elem).data("stuff"), [2,8], "Check stuff property");
+ assert.equal( jQuery( elem ).data( "number" ), true, "Check number property" );
+ assert.deepEqual( jQuery( elem ).data( "stuff" ), [ 2,8 ], "Check stuff property" );
break;
default:
- assert.ok(false, ["Assertion failed on index ", index, ", with data"].join(""));
+ assert.ok( false, [ "Assertion failed on index ", index, ", with data" ].join( "" ) );
}
}
metadata = "
Some stuff Some stuff Some stuff Some stuff ";
- elem = jQuery(metadata).appendTo("#qunit-fixture");
+ elem = jQuery( metadata ).appendTo( "#qunit-fixture" );
- elem.find("li").each(testData);
+ elem.find( "li" ).each( testData );
elem.remove();
-});
+} );
-QUnit.test(".data(Object)", function( assert ) {
- assert.expect(4);
+QUnit.test( ".data(Object)", function( assert ) {
+ assert.expect( 4 );
var obj, jqobj,
- div = jQuery("
");
+ div = jQuery( "
" );
- div.data({ "test": "in", "test2": "in2" });
- assert.equal( div.data("test"), "in", "Verify setting an object in data" );
- assert.equal( div.data("test2"), "in2", "Verify setting an object in data" );
+ div.data( { "test": "in", "test2": "in2" } );
+ assert.equal( div.data( "test" ), "in", "Verify setting an object in data" );
+ assert.equal( div.data( "test2" ), "in2", "Verify setting an object in data" );
- obj = {test:"unset"};
- jqobj = jQuery(obj);
+ obj = { test:"unset" };
+ jqobj = jQuery( obj );
- jqobj.data("test", "unset");
- jqobj.data({ "test": "in", "test2": "in2" });
- assert.equal( jQuery.data(obj)["test"], "in", "Verify setting an object on an object extends the data object" );
- assert.equal( obj["test2"], undefined, "Verify setting an object on an object does not extend the object" );
+ jqobj.data( "test", "unset" );
+ jqobj.data( { "test": "in", "test2": "in2" } );
+ assert.equal( jQuery.data( obj )[ "test" ], "in", "Verify setting an object on an object extends the data object" );
+ assert.equal( obj[ "test2" ], undefined, "Verify setting an object on an object does not extend the object" );
// manually clean up detached elements
div.remove();
-});
+} );
-QUnit.test("jQuery.removeData", function( assert ) {
- assert.expect(10);
+QUnit.test( "jQuery.removeData", function( assert ) {
+ assert.expect( 10 );
var obj,
- div = jQuery("#foo")[0];
- jQuery.data(div, "test", "testing");
- jQuery.removeData(div, "test");
- assert.equal( jQuery.data(div, "test"), undefined, "Check removal of data" );
+ div = jQuery( "#foo" )[ 0 ];
+ jQuery.data( div, "test", "testing" );
+ jQuery.removeData( div, "test" );
+ assert.equal( jQuery.data( div, "test" ), undefined, "Check removal of data" );
- jQuery.data(div, "test2", "testing");
+ jQuery.data( div, "test2", "testing" );
jQuery.removeData( div );
- assert.ok( !jQuery.data(div, "test2"), "Make sure that the data property no longer exists." );
+ assert.ok( !jQuery.data( div, "test2" ), "Make sure that the data property no longer exists." );
assert.ok( !div[ jQuery.expando ], "Make sure the expando no longer exists, as well." );
- jQuery.data(div, {
+ jQuery.data( div, {
test3: "testing",
test4: "testing"
- });
+ } );
jQuery.removeData( div, "test3 test4" );
- assert.ok( !jQuery.data(div, "test3") || jQuery.data(div, "test4"), "Multiple delete with spaces." );
+ assert.ok( !jQuery.data( div, "test3" ) || jQuery.data( div, "test4" ), "Multiple delete with spaces." );
- jQuery.data(div, {
+ jQuery.data( div, {
test3: "testing",
test4: "testing"
- });
+ } );
jQuery.removeData( div, [ "test3", "test4" ] );
- assert.ok( !jQuery.data(div, "test3") || jQuery.data(div, "test4"), "Multiple delete by array." );
+ assert.ok( !jQuery.data( div, "test3" ) || jQuery.data( div, "test4" ), "Multiple delete by array." );
- jQuery.data(div, {
+ jQuery.data( div, {
"test3 test4": "testing",
"test3": "testing"
- });
+ } );
jQuery.removeData( div, "test3 test4" );
- assert.ok( !jQuery.data(div, "test3 test4"), "Multiple delete with spaces deleted key with exact name" );
- assert.ok( jQuery.data(div, "test3"), "Left the partial matched key alone" );
+ assert.ok( !jQuery.data( div, "test3 test4" ), "Multiple delete with spaces deleted key with exact name" );
+ assert.ok( jQuery.data( div, "test3" ), "Left the partial matched key alone" );
obj = {};
- jQuery.data(obj, "test", "testing");
- assert.equal( jQuery(obj).data("test"), "testing", "verify data on plain object");
- jQuery.removeData(obj, "test");
- assert.equal( jQuery.data(obj, "test"), undefined, "Check removal of data on plain object" );
+ jQuery.data( obj, "test", "testing" );
+ assert.equal( jQuery( obj ).data( "test" ), "testing", "verify data on plain object" );
+ jQuery.removeData( obj, "test" );
+ assert.equal( jQuery.data( obj, "test" ), undefined, "Check removal of data on plain object" );
jQuery.data( window, "BAD", true );
jQuery.removeData( window, "BAD" );
assert.ok( !jQuery.data( window, "BAD" ), "Make sure that the value was not still set." );
-});
+} );
-QUnit.test(".removeData()", function( assert ) {
- assert.expect(6);
- var div = jQuery("#foo");
- div.data("test", "testing");
- div.removeData("test");
- assert.equal( div.data("test"), undefined, "Check removal of data" );
+QUnit.test( ".removeData()", function( assert ) {
+ assert.expect( 6 );
+ var div = jQuery( "#foo" );
+ div.data( "test", "testing" );
+ div.removeData( "test" );
+ assert.equal( div.data( "test" ), undefined, "Check removal of data" );
- div.data("test", "testing");
- div.data("test.foo", "testing2");
- div.removeData("test.bar");
- assert.equal( div.data("test.foo"), "testing2", "Make sure data is intact" );
- assert.equal( div.data("test"), "testing", "Make sure data is intact" );
+ div.data( "test", "testing" );
+ div.data( "test.foo", "testing2" );
+ div.removeData( "test.bar" );
+ assert.equal( div.data( "test.foo" ), "testing2", "Make sure data is intact" );
+ assert.equal( div.data( "test" ), "testing", "Make sure data is intact" );
- div.removeData("test");
- assert.equal( div.data("test.foo"), "testing2", "Make sure data is intact" );
- assert.equal( div.data("test"), undefined, "Make sure data is intact" );
+ div.removeData( "test" );
+ assert.equal( div.data( "test.foo" ), "testing2", "Make sure data is intact" );
+ assert.equal( div.data( "test" ), undefined, "Make sure data is intact" );
- div.removeData("test.foo");
- assert.equal( div.data("test.foo"), undefined, "Make sure data is intact" );
-});
+ div.removeData( "test.foo" );
+ assert.equal( div.data( "test.foo" ), undefined, "Make sure data is intact" );
+} );
-if (window.JSON && window.JSON.stringify) {
- QUnit.test("JSON serialization (#8108)", function( assert ) {
- assert.expect(1);
+if ( window.JSON && window.JSON.stringify ) {
+ QUnit.test( "JSON serialization (#8108)", function( assert ) {
+ assert.expect( 1 );
var obj = { "foo": "bar" };
- jQuery.data(obj, "hidden", true);
+ jQuery.data( obj, "hidden", true );
- assert.equal( JSON.stringify(obj), "{\"foo\":\"bar\"}", "Expando is hidden from JSON.stringify" );
- });
+ assert.equal( JSON.stringify( obj ), "{\"foo\":\"bar\"}", "Expando is hidden from JSON.stringify" );
+ } );
}
-QUnit.test(".data should follow html5 specification regarding camel casing", function( assert ) {
- assert.expect(12);
+QUnit.test( ".data should follow html5 specification regarding camel casing", function( assert ) {
+ assert.expect( 12 );
- var div = jQuery("
")
- .prependTo("body");
+ var div = jQuery( "
" )
+ .prependTo( "body" );
- assert.equal( div.data()["wTF"], "ftw", "Verify single letter data-* key" );
- assert.equal( div.data()["bigALittleA"], "bouncing-b", "Verify single letter mixed data-* key" );
+ assert.equal( div.data()[ "wTF" ], "ftw", "Verify single letter data-* key" );
+ assert.equal( div.data()[ "bigALittleA" ], "bouncing-b", "Verify single letter mixed data-* key" );
- assert.equal( div.data()["foo"], "a", "Verify single word data-* key" );
- assert.equal( div.data()["fooBar"], "b", "Verify multiple word data-* key" );
- assert.equal( div.data()["fooBarBaz"], "c", "Verify multiple word data-* key" );
+ assert.equal( div.data()[ "foo" ], "a", "Verify single word data-* key" );
+ assert.equal( div.data()[ "fooBar" ], "b", "Verify multiple word data-* key" );
+ assert.equal( div.data()[ "fooBarBaz" ], "c", "Verify multiple word data-* key" );
- assert.equal( div.data("foo"), "a", "Verify single word data-* key" );
- assert.equal( div.data("fooBar"), "b", "Verify multiple word data-* key" );
- assert.equal( div.data("fooBarBaz"), "c", "Verify multiple word data-* key" );
+ assert.equal( div.data( "foo" ), "a", "Verify single word data-* key" );
+ assert.equal( div.data( "fooBar" ), "b", "Verify multiple word data-* key" );
+ assert.equal( div.data( "fooBarBaz" ), "c", "Verify multiple word data-* key" );
- div.data("foo-bar", "d");
+ div.data( "foo-bar", "d" );
- assert.equal( div.data("fooBar"), "d", "Verify updated data-* key" );
- assert.equal( div.data("foo-bar"), "d", "Verify updated data-* key" );
+ assert.equal( div.data( "fooBar" ), "d", "Verify updated data-* key" );
+ assert.equal( div.data( "foo-bar" ), "d", "Verify updated data-* key" );
- assert.equal( div.data("fooBar"), "d", "Verify updated data-* key (fooBar)" );
- assert.equal( div.data("foo-bar"), "d", "Verify updated data-* key (foo-bar)" );
+ assert.equal( div.data( "fooBar" ), "d", "Verify updated data-* key (fooBar)" );
+ assert.equal( div.data( "foo-bar" ), "d", "Verify updated data-* key (foo-bar)" );
div.remove();
-});
+} );
-QUnit.test(".data should not miss preset data-* w/ hyphenated property names", function( assert ) {
+QUnit.test( ".data should not miss preset data-* w/ hyphenated property names", function( assert ) {
- assert.expect(2);
+ assert.expect( 2 );
- var div = jQuery("
", { id: "hyphened" }).appendTo("#qunit-fixture"),
+ var div = jQuery( "
", { id: "hyphened" } ).appendTo( "#qunit-fixture" ),
test = {
"camelBar": "camelBar",
"hyphen-foo": "hyphen-foo"
@@ -564,47 +564,47 @@ QUnit.test(".data should not miss preset data-* w/ hyphenated property names", f
div.data( test );
- jQuery.each( test , function(i, k) {
- assert.equal( div.data(k), k, "data with property '"+k+"' was correctly found");
- });
-});
+ jQuery.each( test, function( i, k ) {
+ assert.equal( div.data( k ), k, "data with property '" + k + "' was correctly found" );
+ } );
+} );
-QUnit.test("jQuery.data should not miss data-* w/ hyphenated property names #14047", function( assert ) {
+QUnit.test( "jQuery.data should not miss data-* w/ hyphenated property names #14047", function( assert ) {
- assert.expect(1);
+ assert.expect( 1 );
- var div = jQuery("
");
+ var div = jQuery( "
" );
div.data( "foo-bar", "baz" );
- assert.equal( jQuery.data(div[0], "foo-bar"), "baz", "data with property 'foo-bar' was correctly found");
-});
+ assert.equal( jQuery.data( div[ 0 ], "foo-bar" ), "baz", "data with property 'foo-bar' was correctly found" );
+} );
-QUnit.test(".data should not miss attr() set data-* with hyphenated property names", function( assert ) {
- assert.expect(2);
+QUnit.test( ".data should not miss attr() set data-* with hyphenated property names", function( assert ) {
+ assert.expect( 2 );
var a, b;
- a = jQuery("
").appendTo("#qunit-fixture");
+ a = jQuery( "
" ).appendTo( "#qunit-fixture" );
a.attr( "data-long-param", "test" );
- a.data( "long-param", { a: 2 });
+ a.data( "long-param", { a: 2 } );
- assert.deepEqual( a.data("long-param"), { a: 2 }, "data with property long-param was found, 1" );
+ assert.deepEqual( a.data( "long-param" ), { a: 2 }, "data with property long-param was found, 1" );
- b = jQuery("
").appendTo("#qunit-fixture");
+ b = jQuery( "
" ).appendTo( "#qunit-fixture" );
b.attr( "data-long-param", "test" );
b.data( "long-param" );
- b.data( "long-param", { a: 2 });
+ b.data( "long-param", { a: 2 } );
- assert.deepEqual( b.data("long-param"), { a: 2 }, "data with property long-param was found, 2" );
-});
+ assert.deepEqual( b.data( "long-param" ), { a: 2 }, "data with property long-param was found, 2" );
+} );
-QUnit.test(".data always sets data with the camelCased key (gh-2257)", function( assert ) {
+QUnit.test( ".data always sets data with the camelCased key (gh-2257)", function( assert ) {
assert.expect( 18 );
- var div = jQuery("
").appendTo("#qunit-fixture"),
+ var div = jQuery( "
" ).appendTo( "#qunit-fixture" ),
datas = {
"non-empty": "a string",
"empty-string": "",
@@ -626,8 +626,8 @@ QUnit.test(".data always sets data with the camelCased key (gh-2257)", function(
var allData = div.data();
assert.equal( allData[ key ], undefined, ".data does not store with hyphenated keys" );
assert.equal( allData[ jQuery.camelCase( key ) ], val, ".data stores the camelCased key" );
- });
-});
+ } );
+} );
QUnit.test( ".data should not strip more than one hyphen when camelCasing (gh-2070)", function( assert ) {
assert.expect( 3 );
@@ -637,11 +637,11 @@ QUnit.test( ".data should not strip more than one hyphen when camelCasing (gh-20
assert.equal( allData.nestedSingle, "single", "Key is correctly camelCased" );
assert.equal( allData[ "nested-Double" ], "double", "Key with double hyphens is correctly camelCased" );
assert.equal( allData[ "nested--Triple" ], "triple", "Key with triple hyphens is correctly camelCased" );
-});
+} );
-QUnit.test(".data supports interoperable hyphenated/camelCase get/set of properties with arbitrary non-null|NaN|undefined values", function( assert ) {
+QUnit.test( ".data supports interoperable hyphenated/camelCase get/set of properties with arbitrary non-null|NaN|undefined values", function( assert ) {
- var div = jQuery("
", { id: "hyphened" }).appendTo("#qunit-fixture"),
+ var div = jQuery( "
", { id: "hyphened" } ).appendTo( "#qunit-fixture" ),
datas = {
"non-empty": "a string",
"empty-string": "",
@@ -651,6 +651,7 @@ QUnit.test(".data supports interoperable hyphenated/camelCase get/set of propert
"an-object": {},
"bool-true": true,
"bool-false": false,
+
// JSHint enforces double quotes,
// but JSON strings need double quotes to parse
// so we need escaped double quotes here
@@ -667,11 +668,11 @@ QUnit.test(".data supports interoperable hyphenated/camelCase get/set of propert
assert.deepEqual( div.data( key ), val, "get: " + key );
assert.deepEqual( div.data( jQuery.camelCase( key ) ), val, "get: " + jQuery.camelCase( key ) );
- });
-});
+ } );
+} );
-QUnit.test(".data supports interoperable removal of hyphenated/camelCase properties", function( assert ) {
- var div = jQuery("
", { id: "hyphened" }).appendTo("#qunit-fixture"),
+QUnit.test( ".data supports interoperable removal of hyphenated/camelCase properties", function( assert ) {
+ var div = jQuery( "
", { id: "hyphened" } ).appendTo( "#qunit-fixture" ),
datas = {
"non-empty": "a string",
"empty-string": "",
@@ -681,6 +682,7 @@ QUnit.test(".data supports interoperable removal of hyphenated/camelCase propert
"an-object": {},
"bool-true": true,
"bool-false": false,
+
// JSHint enforces double quotes,
// but JSON strings need double quotes to parse
// so we need escaped double quotes here
@@ -699,11 +701,11 @@ QUnit.test(".data supports interoperable removal of hyphenated/camelCase propert
assert.equal( div.data( key ), undefined, "get: " + key );
- });
-});
+ } );
+} );
-QUnit.test(".data supports interoperable removal of properties SET TWICE #13850", function( assert ) {
- var div = jQuery("
").appendTo("#qunit-fixture"),
+QUnit.test( ".data supports interoperable removal of properties SET TWICE #13850", function( assert ) {
+ var div = jQuery( "
" ).appendTo( "#qunit-fixture" ),
datas = {
"non-empty": "a string",
"empty-string": "",
@@ -713,6 +715,7 @@ QUnit.test(".data supports interoperable removal of properties SET TWICE #13850"
"an-object": {},
"bool-true": true,
"bool-false": false,
+
// JSHint enforces double quotes,
// but JSON strings need double quotes to parse
// so we need escaped double quotes here
@@ -728,51 +731,54 @@ QUnit.test(".data supports interoperable removal of properties SET TWICE #13850"
div.removeData( key );
assert.equal( div.data( key ), undefined, "removal: " + key );
- });
-});
+ } );
+} );
QUnit.test( ".removeData supports removal of hyphenated properties via array (#12786, gh-2257)", function( assert ) {
assert.expect( 4 );
var div, plain, compare;
- div = jQuery("
").appendTo("#qunit-fixture");
- plain = jQuery({});
+ div = jQuery( "
" ).appendTo( "#qunit-fixture" );
+ plain = jQuery( {} );
// Properties should always be camelCased
compare = {
+
// From batch assignment .data({ "a-a": 1 })
"aA": 1,
+
// From property, value assignment .data( "b-b", 1 )
"bB": 1
};
// Mixed assignment
- div.data({ "a-a": 1 }).data( "b-b", 1 );
- plain.data({ "a-a": 1 }).data( "b-b", 1 );
+ div.data( { "a-a": 1 } ).data( "b-b", 1 );
+ plain.data( { "a-a": 1 } ).data( "b-b", 1 );
assert.deepEqual( div.data(), compare, "Data appears as expected. (div)" );
assert.deepEqual( plain.data(), compare, "Data appears as expected. (plain)" );
- div.removeData([ "a-a", "b-b" ]);
- plain.removeData([ "a-a", "b-b" ]);
+ div.removeData( [ "a-a", "b-b" ] );
+ plain.removeData( [ "a-a", "b-b" ] );
assert.deepEqual( div.data(), {}, "Data is empty. (div)" );
assert.deepEqual( plain.data(), {}, "Data is empty. (plain)" );
-});
+} );
// Test originally by Moschel
-QUnit.test(".removeData should not throw exceptions. (#10080)", function( assert ) {
- assert.expect(1);
+QUnit.test( ".removeData should not throw exceptions. (#10080)", function( assert ) {
+ assert.expect( 1 );
QUnit.stop();
- var frame = jQuery("#loadediframe");
- jQuery(frame[0].contentWindow).on("unload", function() {
- assert.ok(true, "called unload");
+ var frame = jQuery( "#loadediframe" );
+ jQuery( frame[ 0 ].contentWindow ).on( "unload", function() {
+ assert.ok( true, "called unload" );
QUnit.start();
- });
+ } );
+
// change the url to trigger unload
- frame.attr("src", "data/iframe.html?param=true");
-});
+ frame.attr( "src", "data/iframe.html?param=true" );
+} );
QUnit.test( ".data only checks element attributes once. #8909", function( assert ) {
assert.expect( 2 );
@@ -792,18 +798,18 @@ QUnit.test( ".data only checks element attributes once. #8909", function( assert
// clean up data cache
element.remove();
-});
+} );
QUnit.test( "data-* with JSON value can have newlines", function( assert ) {
- assert.expect(1);
+ assert.expect( 1 );
- var x = jQuery("
");
- assert.equal( x.data("some").foo, "bar", "got a JSON data- attribute with spaces" );
+ var x = jQuery( "
" );
+ assert.equal( x.data( "some" ).foo, "bar", "got a JSON data- attribute with spaces" );
x.remove();
-});
+} );
-QUnit.test(".data doesn't throw when calling selection is empty. #13551", function( assert ) {
- assert.expect(1);
+QUnit.test( ".data doesn't throw when calling selection is empty. #13551", function( assert ) {
+ assert.expect( 1 );
try {
jQuery( null ).data( "prop" );
@@ -811,9 +817,9 @@ QUnit.test(".data doesn't throw when calling selection is empty. #13551", functi
} catch ( e ) {
assert.ok( false, e.message );
}
-});
+} );
-QUnit.test("jQuery.acceptData", function( assert ) {
+QUnit.test( "jQuery.acceptData", function( assert ) {
assert.expect( 10 );
var flash, pdf;
@@ -838,19 +844,19 @@ QUnit.test("jQuery.acceptData", function( assert ) {
assert.ok( jQuery.acceptData(
jQuery( "#form" ).append( "
" )[ 0 ] ),
"form with aliased DOM properties" );
-});
+} );
-QUnit.test("Check proper data removal of non-element descendants nodes (#8335)", function( assert ) {
+QUnit.test( "Check proper data removal of non-element descendants nodes (#8335)", function( assert ) {
assert.expect( 1 );
- var div = jQuery("
text
"),
+ var div = jQuery( "
text
" ),
text = div.contents();
text.data( "test", "test" ); // This should be a noop.
div.remove();
- assert.ok( !text.data("test"), "Be sure data is not stored in non-element" );
-});
+ assert.ok( !text.data( "test" ), "Be sure data is not stored in non-element" );
+} );
testIframeWithCallback(
"enumerate data attrs on body (#14894)",
@@ -876,4 +882,4 @@ QUnit.test( "Check that the expando is removed when there's no more data", funct
assert.ok( false, "Expando was not removed when there was no more data" );
}
}
-});
+} );
diff --git a/test/unit/deferred.js b/test/unit/deferred.js
index 83b7897af..33b5b4f16 100644
--- a/test/unit/deferred.js
+++ b/test/unit/deferred.js
@@ -1,6 +1,6 @@
QUnit.module( "deferred", {
teardown: moduleTeardown
-});
+} );
jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
@@ -16,32 +16,32 @@ jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
assert.ok( jQuery.isFunction( defer.pipe ), "defer.pipe is a function" );
- createDeferred().resolve().done(function() {
+ createDeferred().resolve().done( function() {
assert.ok( true, "Success on resolve" );
assert.strictEqual( this.state(), "resolved", "Deferred is resolved (state)" );
- }).fail(function() {
+ } ).fail( function() {
assert.ok( false, "Error on resolve" );
- }).always(function() {
+ } ).always( function() {
assert.ok( true, "Always callback on resolve" );
- });
+ } );
- createDeferred().reject().done(function() {
+ createDeferred().reject().done( function() {
assert.ok( false, "Success on reject" );
- }).fail(function() {
+ } ).fail( function() {
assert.ok( true, "Error on reject" );
assert.strictEqual( this.state(), "rejected", "Deferred is rejected (state)" );
- }).always(function() {
+ } ).always( function() {
assert.ok( true, "Always callback on reject" );
- });
+ } );
- createDeferred(function( defer ) {
+ createDeferred( function( defer ) {
assert.ok( this === defer, "Defer passed as this & first argument" );
- this.resolve("done");
- }).done(function( value ) {
+ this.resolve( "done" );
+ } ).done( function( value ) {
assert.strictEqual( value, "done", "Passed function executed" );
- });
+ } );
- createDeferred(function( defer ) {
+ createDeferred( function( defer ) {
var promise = defer.promise(),
func = function() {},
funcPromise = defer.promise( func );
@@ -54,17 +54,17 @@ jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
if ( promise[ key ] !== func[ key ] ) {
assert.strictEqual( func[ key ], promise[ key ], key + " is the same" );
}
- });
- });
+ } );
+ } );
jQuery.expandedEach = jQuery.each;
- jQuery.expandedEach( "resolve reject".split(" "), function( _, change ) {
- createDeferred(function( defer ) {
+ jQuery.expandedEach( "resolve reject".split( " " ), function( _, change ) {
+ createDeferred( function( defer ) {
assert.strictEqual( defer.state(), "pending", "pending after creation" );
var checked = 0;
- defer.progress(function( value ) {
+ defer.progress( function( value ) {
assert.strictEqual( value, checked, "Progress: right value (" + value + ") received" );
- });
+ } );
for ( checked = 0; checked < 3; checked++ ) {
defer.notify( checked );
}
@@ -72,11 +72,10 @@ jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
defer[ change ]();
assert.notStrictEqual( defer.state(), "pending", "not pending after " + change );
defer.notify();
- });
- });
- });
-});
-
+ } );
+ } );
+ } );
+} );
QUnit.test( "jQuery.Deferred - chainability", function( assert ) {
@@ -85,13 +84,13 @@ QUnit.test( "jQuery.Deferred - chainability", function( assert ) {
assert.expect( 10 );
jQuery.expandedEach = jQuery.each;
- jQuery.expandedEach( "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split(" "), function( _, method ) {
+ jQuery.expandedEach( "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split( " " ), function( _, method ) {
var object = {
m: defer[ method ]
};
assert.strictEqual( object.m(), object, method + " is chainable" );
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - filtering (done)", function( assert ) {
@@ -99,36 +98,36 @@ QUnit.test( "jQuery.Deferred.then - filtering (done)", function( assert ) {
var value1, value2, value3,
defer = jQuery.Deferred(),
- piped = defer.then(function( a, b ) {
+ piped = defer.then( function( a, b ) {
return a * b;
- }),
+ } ),
done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
- piped.done(function( result ) {
+ piped.done( function( result ) {
value3 = result;
- });
+ } );
- defer.done(function( a, b ) {
+ defer.done( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
- defer.resolve( 2, 3 ).then(function() {
+ defer.resolve( 2, 3 ).then( function() {
assert.strictEqual( value1, 2, "first resolve value ok" );
assert.strictEqual( value2, 3, "second resolve value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done.pop().call();
- });
+ } );
- jQuery.Deferred().reject().then(function() {
+ jQuery.Deferred().reject().then( function() {
assert.ok( false, "then should not be called on reject" );
- }).then( null, done.pop() );
+ } ).then( null, done.pop() );
- jQuery.Deferred().resolve().then( jQuery.noop ).done(function( value ) {
+ jQuery.Deferred().resolve().then( jQuery.noop ).done( function( value ) {
assert.strictEqual( value, undefined, "then done callback can return undefined/null" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - filtering (fail)", function( assert ) {
@@ -138,70 +137,70 @@ QUnit.test( "jQuery.Deferred.then - filtering (fail)", function( assert ) {
defer = jQuery.Deferred(),
piped = defer.then( null, function( a, b ) {
return a * b;
- }),
+ } ),
done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
- piped.done(function( result ) {
+ piped.done( function( result ) {
value3 = result;
- });
+ } );
- defer.fail(function( a, b ) {
+ defer.fail( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.reject( 2, 3 ).then( null, function() {
assert.strictEqual( value1, 2, "first reject value ok" );
assert.strictEqual( value2, 3, "second reject value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done.pop().call();
- });
+ } );
jQuery.Deferred().resolve().then( null, function() {
assert.ok( false, "then should not be called on resolve" );
- }).then( done.pop() );
+ } ).then( done.pop() );
- jQuery.Deferred().reject().then( null, jQuery.noop ).done(function( value ) {
+ jQuery.Deferred().reject().then( null, jQuery.noop ).done( function( value ) {
assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.catch", function( assert ) {
assert.expect( 4 );
var value1, value2, value3,
defer = jQuery.Deferred(),
- piped = defer[ "catch" ](function( a, b ) {
+ piped = defer[ "catch" ]( function( a, b ) {
return a * b;
- }),
+ } ),
done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
- piped.done(function( result ) {
+ piped.done( function( result ) {
value3 = result;
- });
+ } );
- defer.fail(function( a, b ) {
+ defer.fail( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
- defer.reject( 2, 3 )[ "catch" ](function() {
+ defer.reject( 2, 3 )[ "catch" ]( function() {
assert.strictEqual( value1, 2, "first reject value ok" );
assert.strictEqual( value2, 3, "second reject value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done.pop().call();
- });
+ } );
- jQuery.Deferred().resolve()[ "catch" ](function() {
+ jQuery.Deferred().resolve()[ "catch" ]( function() {
assert.ok( false, "then should not be called on resolve" );
- }).then( done.pop() );
+ } ).then( done.pop() );
- jQuery.Deferred().reject()[ "catch" ]( jQuery.noop ).done(function( value ) {
+ jQuery.Deferred().reject()[ "catch" ]( jQuery.noop ).done( function( value ) {
assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - filtering (fail)", function( assert ) {
@@ -211,34 +210,34 @@ QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - filtering (fail)", function( ass
defer = jQuery.Deferred(),
piped = defer.pipe( null, function( a, b ) {
return a * b;
- }),
+ } ),
done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
- piped.fail(function( result ) {
+ piped.fail( function( result ) {
value3 = result;
- });
+ } );
- defer.fail(function( a, b ) {
+ defer.fail( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.reject( 2, 3 ).pipe( null, function() {
assert.strictEqual( value1, 2, "first reject value ok" );
assert.strictEqual( value2, 3, "second reject value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done.pop().call();
- });
+ } );
jQuery.Deferred().resolve().pipe( null, function() {
assert.ok( false, "then should not be called on resolve" );
- }).then( done.pop() );
+ } ).then( done.pop() );
- jQuery.Deferred().reject().pipe( null, jQuery.noop ).fail(function( value ) {
+ jQuery.Deferred().reject().pipe( null, jQuery.noop ).fail( function( value ) {
assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - filtering (progress)", function( assert ) {
@@ -248,25 +247,25 @@ QUnit.test( "jQuery.Deferred.then - filtering (progress)", function( assert ) {
defer = jQuery.Deferred(),
piped = defer.then( null, null, function( a, b ) {
return a * b;
- }),
+ } ),
done = assert.async();
- piped.progress(function( result ) {
+ piped.progress( function( result ) {
value3 = result;
- });
+ } );
- defer.progress(function( a, b ) {
+ defer.progress( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.notify( 2, 3 ).then( null, null, function() {
assert.strictEqual( value1, 2, "first progress value ok" );
assert.strictEqual( value2, 3, "second progress value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - deferred (done)", function( assert ) {
@@ -274,31 +273,31 @@ QUnit.test( "jQuery.Deferred.then - deferred (done)", function( assert ) {
var value1, value2, value3,
defer = jQuery.Deferred(),
- piped = defer.then(function( a, b ) {
- return jQuery.Deferred(function( defer ) {
+ piped = defer.then( function( a, b ) {
+ return jQuery.Deferred( function( defer ) {
defer.reject( a * b );
- });
- }),
+ } );
+ } ),
done = assert.async();
- piped.fail(function( result ) {
+ piped.fail( function( result ) {
value3 = result;
- });
+ } );
- defer.done(function( a, b ) {
+ defer.done( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.resolve( 2, 3 );
- piped.fail(function() {
+ piped.fail( function() {
assert.strictEqual( value1, 2, "first resolve value ok" );
assert.strictEqual( value2, 3, "second resolve value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - deferred (fail)", function( assert ) {
@@ -307,30 +306,30 @@ QUnit.test( "jQuery.Deferred.then - deferred (fail)", function( assert ) {
var value1, value2, value3,
defer = jQuery.Deferred(),
piped = defer.then( null, function( a, b ) {
- return jQuery.Deferred(function( defer ) {
+ return jQuery.Deferred( function( defer ) {
defer.resolve( a * b );
- });
- }),
+ } );
+ } ),
done = assert.async();
- piped.done(function( result ) {
+ piped.done( function( result ) {
value3 = result;
- });
+ } );
- defer.fail(function( a, b ) {
+ defer.fail( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.reject( 2, 3 );
- piped.done(function() {
+ piped.done( function() {
assert.strictEqual( value1, 2, "first reject value ok" );
assert.strictEqual( value2, 3, "second reject value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - deferred (progress)", function( assert ) {
@@ -339,38 +338,38 @@ QUnit.test( "jQuery.Deferred.then - deferred (progress)", function( assert ) {
var value1, value2, value3,
defer = jQuery.Deferred(),
piped = defer.then( null, null, function( a, b ) {
- return jQuery.Deferred(function( defer ) {
+ return jQuery.Deferred( function( defer ) {
defer.resolve( a * b );
- });
- }),
+ } );
+ } ),
done = assert.async();
- piped.progress(function( result ) {
- return jQuery.Deferred().resolve().then(function() {
+ piped.progress( function( result ) {
+ return jQuery.Deferred().resolve().then( function() {
return result;
- }).then(function( result ) {
+ } ).then( function( result ) {
value3 = result;
- });
- });
+ } );
+ } );
- defer.progress(function( a, b ) {
+ defer.progress( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.notify( 2, 3 );
piped.then( null, null, function( result ) {
- return jQuery.Deferred().resolve().then(function() {
+ return jQuery.Deferred().resolve().then( function() {
return result;
- }).then(function() {
+ } ).then( function() {
assert.strictEqual( value1, 2, "first progress value ok" );
assert.strictEqual( value2, 3, "second progress value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done();
- });
- });
-});
+ } );
+ } );
+} );
QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - deferred (progress)", function( assert ) {
@@ -379,30 +378,30 @@ QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - deferred (progress)", function(
var value1, value2, value3,
defer = jQuery.Deferred(),
piped = defer.pipe( null, null, function( a, b ) {
- return jQuery.Deferred(function( defer ) {
+ return jQuery.Deferred( function( defer ) {
defer.resolve( a * b );
- });
- }),
+ } );
+ } ),
done = assert.async();
- piped.done(function( result ) {
+ piped.done( function( result ) {
value3 = result;
- });
+ } );
- defer.progress(function( a, b ) {
+ defer.progress( function( a, b ) {
value1 = a;
value2 = b;
- });
+ } );
defer.notify( 2, 3 );
- piped.done(function() {
+ piped.done( function() {
assert.strictEqual( value1, 2, "first progress value ok" );
assert.strictEqual( value2, 3, "second progress value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - context", function( assert ) {
@@ -412,48 +411,48 @@ QUnit.test( "jQuery.Deferred.then - context", function( assert ) {
context = {},
done = jQuery.map( new Array( 4 ), function() { return assert.async(); } );
- jQuery.Deferred().resolveWith( context, [ 2 ] ).then(function( value ) {
+ jQuery.Deferred().resolveWith( context, [ 2 ] ).then( function( value ) {
return value * 3;
- }).done(function( value ) {
+ } ).done( function( value ) {
assert.notStrictEqual( this, context, "custom context not propagated through .then" );
assert.strictEqual( value, 6, "proper value received" );
done.pop().call();
- });
+ } );
- jQuery.Deferred().resolve().then(function() {
+ jQuery.Deferred().resolve().then( function() {
return jQuery.Deferred().resolveWith( context );
- }).done(function() {
+ } ).done( function() {
assert.strictEqual( this, context,
"custom context of returned deferred correctly propagated" );
done.pop().call();
- });
+ } );
defer = jQuery.Deferred();
- piped = defer.then(function( value ) {
+ piped = defer.then( function( value ) {
return value * 3;
- });
+ } );
defer.resolve( 2 );
- piped.done(function( value ) {
+ piped.done( function( value ) {
assert.strictEqual( this, piped,
"default context gets updated to latest promise in the chain" );
assert.strictEqual( value, 6, "proper value received" );
done.pop().call();
- });
+ } );
defer2 = jQuery.Deferred();
piped2 = defer2.then();
defer2.resolve( 2 );
- piped2.done(function( value ) {
+ piped2.done( function( value ) {
assert.strictEqual( this, piped2,
"default context updated to latest promise in the chain (without passing function)" );
assert.strictEqual( value, 2, "proper value received (without passing function)" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - context", function( assert ) {
@@ -463,66 +462,66 @@ QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - context", function( assert ) {
context = {},
done = jQuery.map( new Array( 4 ), function() { return assert.async(); } );
- jQuery.Deferred().resolveWith( context, [ 2 ] ).pipe(function( value ) {
+ jQuery.Deferred().resolveWith( context, [ 2 ] ).pipe( function( value ) {
return value * 3;
- }).done(function( value ) {
+ } ).done( function( value ) {
assert.strictEqual( this, context, "[PIPE ONLY] custom context correctly propagated" );
assert.strictEqual( value, 6, "proper value received" );
done.pop().call();
- });
+ } );
- jQuery.Deferred().resolve().pipe(function() {
- return jQuery.Deferred().resolveWith(context);
- }).done(function() {
+ jQuery.Deferred().resolve().pipe( function() {
+ return jQuery.Deferred().resolveWith( context );
+ } ).done( function() {
assert.strictEqual( this, context,
"custom context of returned deferred correctly propagated" );
done.pop().call();
- });
+ } );
defer = jQuery.Deferred();
- piped = defer.pipe(function( value ) {
+ piped = defer.pipe( function( value ) {
return value * 3;
- });
+ } );
defer.resolve( 2 );
- piped.done(function( value ) {
+ piped.done( function( value ) {
assert.strictEqual( this, piped,
"default context gets updated to latest promise in the chain" );
assert.strictEqual( value, 6, "proper value received" );
done.pop().call();
- });
+ } );
defer2 = jQuery.Deferred();
piped2 = defer2.pipe();
defer2.resolve( 2 );
- piped2.done(function( value ) {
+ piped2.done( function( value ) {
assert.strictEqual( this, piped2,
"default context updated to latest promise in the chain (without passing function)" );
assert.strictEqual( value, 2, "proper value received (without passing function)" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.asyncTest( "jQuery.Deferred.then - spec compatibility", function( assert ) {
assert.expect( 1 );
- var defer = jQuery.Deferred().done(function() {
+ var defer = jQuery.Deferred().done( function() {
setTimeout( start );
throw new Error();
- });
+ } );
- defer.then(function() {
+ defer.then( function() {
assert.ok( true, "errors in .done callbacks don't stop .then handlers" );
- });
+ } );
try {
defer.resolve();
} catch ( _ ) {}
-});
+} );
QUnit.test( "jQuery.Deferred - 1.x/2.x compatibility", function( assert ) {
@@ -534,46 +533,46 @@ QUnit.test( "jQuery.Deferred - 1.x/2.x compatibility", function( assert ) {
thenable.unwrapped = false;
- jQuery.Deferred().resolve( 1, 2 ).then(function() {
+ jQuery.Deferred().resolve( 1, 2 ).then( function() {
assert.deepEqual( [].slice.call( arguments ), [ 1, 2 ],
".then fulfillment callbacks receive all resolution values" );
done.pop().call();
- });
+ } );
jQuery.Deferred().reject( 1, 2 ).then( null, function() {
assert.deepEqual( [].slice.call( arguments ), [ 1, 2 ],
".then rejection callbacks receive all rejection values" );
done.pop().call();
- });
+ } );
jQuery.Deferred().notify( 1, 2 ).then( null, null, function() {
assert.deepEqual( [].slice.call( arguments ), [ 1, 2 ],
".then progress callbacks receive all progress values" );
done.pop().call();
- });
+ } );
- jQuery.Deferred().resolveWith( context ).then(function() {
+ jQuery.Deferred().resolveWith( context ).then( function() {
assert.deepEqual( this, context, ".then fulfillment callbacks receive context" );
done.pop().call();
- });
+ } );
jQuery.Deferred().rejectWith( context ).then( null, function() {
assert.deepEqual( this, context, ".then rejection callbacks receive context" );
done.pop().call();
- });
+ } );
jQuery.Deferred().notifyWith( context ).then( null, null, function() {
assert.deepEqual( this, context, ".then progress callbacks receive context" );
done.pop().call();
- });
+ } );
- jQuery.Deferred().resolve( thenable ).done(function( value ) {
+ jQuery.Deferred().resolve( thenable ).done( function( value ) {
assert.strictEqual( value, thenable, ".done doesn't unwrap thenables" );
done.pop().call();
- });
+ } );
jQuery.Deferred().notify( thenable ).then().then( null, null, function( value ) {
assert.strictEqual( value, "thenable fulfillment",
".then implicit progress callbacks unwrap thenables" );
done.pop().call();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.Deferred.then - progress and thenables", function( assert ) {
@@ -590,16 +589,16 @@ QUnit.test( "jQuery.Deferred.then - progress and thenables", function( assert )
trigger.then( null, null, function() {
var notifier = jQuery.Deferred().notify( "foo" );
- setTimeout(function() {
+ setTimeout( function() {
notifier.notify( "bar" ).resolve( "baz" );
- });
+ } );
return notifier;
- }).then( failer( "fulfill" ), failer( "reject" ), function( v ) {
+ } ).then( failer( "fulfill" ), failer( "reject" ), function( v ) {
assert.strictEqual( v, expectedProgress.shift(), "expected progress value" );
done.pop().call();
- });
+ } );
trigger.notify();
-});
+} );
QUnit.test( "jQuery.Deferred - notify and resolve", function( assert ) {
@@ -643,18 +642,19 @@ QUnit.test( "jQuery.Deferred - notify and resolve", function( assert ) {
notifiedResolved.then( null, null, function() {
return jQuery.Deferred().notify( "baz" ).resolve( "quux" );
} ).progress( function( v ) {
+
// Progress from the surrogate deferred is ignored
assert.strictEqual( v, "quux", "deferred replaced then'd progress value" );
done.pop().call();
} );
-});
+} );
QUnit.test( "jQuery.when", function( assert ) {
assert.expect( 37 );
// Some other objects
- jQuery.each({
+ jQuery.each( {
"an empty string": "",
"a non-empty string": "some string",
"zero": 0,
@@ -669,21 +669,21 @@ QUnit.test( "jQuery.when", function( assert ) {
}, function( message, value ) {
assert.ok(
jQuery.isFunction(
- jQuery.when( value ).done(function( resolveValue ) {
+ jQuery.when( value ).done( function( resolveValue ) {
assert.strictEqual( this, window, "Context is the global object with " + message );
assert.strictEqual( resolveValue, value, "Test the promise was resolved with " + message );
- }).promise
+ } ).promise
),
"Test " + message + " triggers the creation of a new Promise"
);
- });
+ } );
assert.ok(
jQuery.isFunction(
- jQuery.when().done(function( resolveValue ) {
+ jQuery.when().done( function( resolveValue ) {
assert.strictEqual( this, window, "Test the promise was resolved with window as its context" );
assert.strictEqual( resolveValue, undefined, "Test the promise was resolved with no parameter" );
- }).promise
+ } ).promise
),
"Test calling when with no parameter triggers the creation of a new Promise"
);
@@ -691,23 +691,23 @@ QUnit.test( "jQuery.when", function( assert ) {
var cache,
context = {};
- jQuery.when( jQuery.Deferred().resolveWith( context ) ).done(function() {
+ jQuery.when( jQuery.Deferred().resolveWith( context ) ).done( function() {
assert.strictEqual( this, context, "when( promise ) propagates context" );
- });
+ } );
- jQuery.each([ 1, 2, 3 ], function( k, i ) {
+ jQuery.each( [ 1, 2, 3 ], function( k, i ) {
- jQuery.when( cache || jQuery.Deferred(function() {
+ jQuery.when( cache || jQuery.Deferred( function() {
this.resolve( i );
- })
- ).done(function( value ) {
+ } )
+ ).done( function( value ) {
assert.strictEqual( value, 1, "Function executed" + ( i > 1 ? " only once" : "" ) );
cache = value;
- });
+ } );
- });
-});
+ } );
+} );
QUnit.test( "jQuery.when - joined", function( assert ) {
@@ -762,7 +762,7 @@ QUnit.test( "jQuery.when - joined", function( assert ) {
context2 = defer2 && jQuery.isFunction( defer2.promise ) ? defer2.promise() :
( defer2.then ? window : undefined );
- jQuery.when( defer1, defer2 ).done(function( a, b ) {
+ jQuery.when( defer1, defer2 ).done( function( a, b ) {
if ( shouldResolve ) {
assert.deepEqual( [ a, b ], expected, code + " => resolve" );
assert.strictEqual( this[ 0 ], context1, code + " => first context OK" );
@@ -770,22 +770,22 @@ QUnit.test( "jQuery.when - joined", function( assert ) {
} else {
assert.ok( false, code + " => resolve" );
}
- }).fail(function( a, b ) {
+ } ).fail( function( a, b ) {
if ( shouldError ) {
assert.deepEqual( [ a, b ], expected, code + " => reject" );
} else {
assert.ok( false, code + " => reject" );
}
- }).progress(function( a, b ) {
+ } ).progress( function( a, b ) {
assert.deepEqual( [ a, b ], expectedNotify, code + " => progress" );
assert.strictEqual( this[ 0 ], expectedNotify[ 0 ] ? context1 : undefined, code + " => first context OK" );
assert.strictEqual( this[ 1 ], expectedNotify[ 1 ] ? context2 : undefined, code + " => second context OK" );
- }).always( restart );
- });
- });
+ } ).always( restart );
+ } );
+ } );
deferreds.eventuallyFulfilled.resolve( 1 );
deferreds.eventuallyRejected.reject( 0 );
-});
+} );
QUnit.test( "jQuery.when - resolved", function( assert ) {
@@ -795,18 +795,18 @@ QUnit.test( "jQuery.when - resolved", function( assert ) {
b = jQuery.Deferred().notify( 2 ).resolve( 5 ),
c = jQuery.Deferred().notify( 3 ).resolve( 6 );
- jQuery.when( a, b, c ).progress(function( a, b, c ) {
+ jQuery.when( a, b, c ).progress( function( a, b, c ) {
assert.strictEqual( a, 1, "first notify value ok" );
assert.strictEqual( b, 2, "second notify value ok" );
assert.strictEqual( c, 3, "third notify value ok" );
- }).done(function( a, b, c ) {
+ } ).done( function( a, b, c ) {
assert.strictEqual( a, 4, "first resolve value ok" );
assert.strictEqual( b, 5, "second resolve value ok" );
assert.strictEqual( c, 6, "third resolve value ok" );
- }).fail(function() {
+ } ).fail( function() {
assert.ok( false, "Error on resolve" );
- });
-});
+ } );
+} );
QUnit.test( "jQuery.when - filtering", function( assert ) {
@@ -821,12 +821,12 @@ QUnit.test( "jQuery.when - filtering", function( assert ) {
jQuery.when(
jQuery.Deferred().resolve( 3 ).then( increment ),
jQuery.Deferred().reject( 5 ).then( null, increment )
- ).done(function( four, six ) {
+ ).done( function( four, six ) {
assert.strictEqual( four, 4, "resolved value incremented" );
assert.strictEqual( six, 6, "rejected value incremented" );
QUnit.start();
- });
-});
+ } );
+} );
QUnit.test( "jQuery.when - exceptions", function( assert ) {
@@ -838,14 +838,14 @@ QUnit.test( "jQuery.when - exceptions", function( assert ) {
QUnit.stop();
- jQuery.Deferred().resolve().then( woops ).fail(function( doneException ) {
+ jQuery.Deferred().resolve().then( woops ).fail( function( doneException ) {
assert.strictEqual( doneException, "exception thrown", "throwing in done handler" );
- jQuery.Deferred().reject().then( null, woops ).fail(function( failException ) {
+ jQuery.Deferred().reject().then( null, woops ).fail( function( failException ) {
assert.strictEqual( failException, "exception thrown", "throwing in fail handler" );
QUnit.start();
- });
- });
-});
+ } );
+ } );
+} );
QUnit.test( "jQuery.when - chaining", function( assert ) {
@@ -868,13 +868,13 @@ QUnit.test( "jQuery.when - chaining", function( assert ) {
jQuery.Deferred().reject( 5 ).then( null, chain ),
jQuery.Deferred().resolve( 3 ).then( chainStandard ),
jQuery.Deferred().reject( 5 ).then( null, chainStandard )
- ).done(function( v1, v2, s1, s2 ) {
+ ).done( function( v1, v2, s1, s2 ) {
assert.strictEqual( v1, "other deferred", "chaining in done handler" );
assert.strictEqual( v2, "other deferred", "chaining in fail handler" );
assert.strictEqual( s1, "std deferred", "chaining thenable in done handler" );
assert.strictEqual( s2, "std deferred", "chaining thenable in fail handler" );
QUnit.start();
- });
+ } );
defer.resolve( "other deferred" );
-});
+} );
diff --git a/test/unit/deprecated.js b/test/unit/deprecated.js
index 2a2357a52..52c137dc3 100644
--- a/test/unit/deprecated.js
+++ b/test/unit/deprecated.js
@@ -1,2 +1,2 @@
-QUnit.module("deprecated", { teardown: moduleTeardown });
+QUnit.module( "deprecated", { teardown: moduleTeardown } );
diff --git a/test/unit/dimensions.js b/test/unit/dimensions.js
index 5b471094f..c2f08a0bd 100644
--- a/test/unit/dimensions.js
+++ b/test/unit/dimensions.js
@@ -1,10 +1,10 @@
-(function() {
+( function() {
if ( !jQuery.fn.width ) {
return;
}
-QUnit.module("dimensions", { teardown: moduleTeardown });
+QUnit.module( "dimensions", { teardown: moduleTeardown } );
function pass( val ) {
return val;
@@ -29,111 +29,111 @@ function fn( val ) {
*/
function testWidth( val, assert ) {
- assert.expect(9);
+ assert.expect( 9 );
var $div, blah;
- $div = jQuery("#nothiddendiv");
- $div.width( val(30) );
- assert.equal($div.width(), 30, "Test set to 30 correctly");
+ $div = jQuery( "#nothiddendiv" );
+ $div.width( val( 30 ) );
+ assert.equal( $div.width(), 30, "Test set to 30 correctly" );
$div.hide();
- assert.equal($div.width(), 30, "Test hidden div");
+ assert.equal( $div.width(), 30, "Test hidden div" );
$div.show();
- $div.width( val(-1) ); // handle negative numbers by setting to 0 #11604
- assert.equal($div.width(), 0, "Test negative width normalized to 0");
- $div.css("padding", "20px");
- assert.equal($div.width(), 0, "Test padding specified with pixels");
- $div.css("border", "2px solid #fff");
- assert.equal($div.width(), 0, "Test border specified with pixels");
+ $div.width( val( -1 ) ); // handle negative numbers by setting to 0 #11604
+ assert.equal( $div.width(), 0, "Test negative width normalized to 0" );
+ $div.css( "padding", "20px" );
+ assert.equal( $div.width(), 0, "Test padding specified with pixels" );
+ $div.css( "border", "2px solid #fff" );
+ assert.equal( $div.width(), 0, "Test border specified with pixels" );
- $div.css({ "display": "", "border": "", "padding": "" });
+ $div.css( { "display": "", "border": "", "padding": "" } );
- jQuery("#nothiddendivchild").css({ "width": 20, "padding": "3px", "border": "2px solid #fff" });
- assert.equal(jQuery("#nothiddendivchild").width(), 20, "Test child width with border and padding");
- jQuery("#nothiddendiv, #nothiddendivchild").css({ "border": "", "padding": "", "width": "" });
+ jQuery( "#nothiddendivchild" ).css( { "width": 20, "padding": "3px", "border": "2px solid #fff" } );
+ assert.equal( jQuery( "#nothiddendivchild" ).width(), 20, "Test child width with border and padding" );
+ jQuery( "#nothiddendiv, #nothiddendivchild" ).css( { "border": "", "padding": "", "width": "" } );
- blah = jQuery("blah");
- assert.equal( blah.width( val(10) ), blah, "Make sure that setting a width on an empty set returns the set." );
- assert.equal( blah.width(), null, "Make sure 'null' is returned on an empty set");
+ blah = jQuery( "blah" );
+ assert.equal( blah.width( val( 10 ) ), blah, "Make sure that setting a width on an empty set returns the set." );
+ assert.equal( blah.width(), null, "Make sure 'null' is returned on an empty set" );
- assert.equal( jQuery(window).width(), document.documentElement.clientWidth, "Window width is equal to width reported by window/document." );
+ assert.equal( jQuery( window ).width(), document.documentElement.clientWidth, "Window width is equal to width reported by window/document." );
- QUnit.expectJqData( this, $div[0], "olddisplay" );
+ QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
}
-QUnit.test("width()", function( assert ) {
+QUnit.test( "width()", function( assert ) {
testWidth( pass, assert );
-});
+} );
-QUnit.test("width(Function)", function( assert ) {
+QUnit.test( "width(Function)", function( assert ) {
testWidth( fn, assert );
-});
+} );
-QUnit.test("width(Function(args))", function( assert ) {
+QUnit.test( "width(Function(args))", function( assert ) {
assert.expect( 2 );
- var $div = jQuery("#nothiddendiv");
- $div.width( 30 ).width(function(i, width) {
+ var $div = jQuery( "#nothiddendiv" );
+ $div.width( 30 ).width( function( i, width ) {
assert.equal( width, 30, "Make sure previous value is correct." );
return width + 1;
- });
+ } );
assert.equal( $div.width(), 31, "Make sure value was modified correctly." );
-});
+} );
function testHeight( val, assert ) {
- assert.expect(9);
+ assert.expect( 9 );
var $div, blah;
- $div = jQuery("#nothiddendiv");
- $div.height( val(30) );
- assert.equal($div.height(), 30, "Test set to 30 correctly");
+ $div = jQuery( "#nothiddendiv" );
+ $div.height( val( 30 ) );
+ assert.equal( $div.height(), 30, "Test set to 30 correctly" );
$div.hide();
- assert.equal($div.height(), 30, "Test hidden div");
+ assert.equal( $div.height(), 30, "Test hidden div" );
$div.show();
- $div.height( val(-1) ); // handle negative numbers by setting to 0 #11604
- assert.equal($div.height(), 0, "Test negative height normalized to 0");
- $div.css("padding", "20px");
- assert.equal($div.height(), 0, "Test padding specified with pixels");
- $div.css("border", "2px solid #fff");
- assert.equal($div.height(), 0, "Test border specified with pixels");
+ $div.height( val( -1 ) ); // handle negative numbers by setting to 0 #11604
+ assert.equal( $div.height(), 0, "Test negative height normalized to 0" );
+ $div.css( "padding", "20px" );
+ assert.equal( $div.height(), 0, "Test padding specified with pixels" );
+ $div.css( "border", "2px solid #fff" );
+ assert.equal( $div.height(), 0, "Test border specified with pixels" );
- $div.css({ "display": "", "border": "", "padding": "", "height": "1px" });
+ $div.css( { "display": "", "border": "", "padding": "", "height": "1px" } );
- jQuery("#nothiddendivchild").css({ "height": 20, "padding": "3px", "border": "2px solid #fff" });
- assert.equal(jQuery("#nothiddendivchild").height(), 20, "Test child height with border and padding");
- jQuery("#nothiddendiv, #nothiddendivchild").css({ "border": "", "padding": "", "height": "" });
+ jQuery( "#nothiddendivchild" ).css( { "height": 20, "padding": "3px", "border": "2px solid #fff" } );
+ assert.equal( jQuery( "#nothiddendivchild" ).height(), 20, "Test child height with border and padding" );
+ jQuery( "#nothiddendiv, #nothiddendivchild" ).css( { "border": "", "padding": "", "height": "" } );
- blah = jQuery("blah");
- assert.equal( blah.height( val(10) ), blah, "Make sure that setting a height on an empty set returns the set." );
- assert.equal( blah.height(), null, "Make sure 'null' is returned on an empty set");
+ blah = jQuery( "blah" );
+ assert.equal( blah.height( val( 10 ) ), blah, "Make sure that setting a height on an empty set returns the set." );
+ assert.equal( blah.height(), null, "Make sure 'null' is returned on an empty set" );
- assert.equal( jQuery(window).height(), document.documentElement.clientHeight, "Window width is equal to width reported by window/document." );
+ assert.equal( jQuery( window ).height(), document.documentElement.clientHeight, "Window width is equal to width reported by window/document." );
- QUnit.expectJqData( this, $div[0], "olddisplay" );
+ QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
}
-QUnit.test("height()", function( assert ) {
+QUnit.test( "height()", function( assert ) {
testHeight( pass, assert );
-});
+} );
-QUnit.test("height(Function)", function( assert ) {
+QUnit.test( "height(Function)", function( assert ) {
testHeight( fn, assert );
-});
+} );
-QUnit.test("height(Function(args))", function( assert ) {
+QUnit.test( "height(Function(args))", function( assert ) {
assert.expect( 2 );
- var $div = jQuery("#nothiddendiv");
- $div.height( 30 ).height(function(i, height) {
+ var $div = jQuery( "#nothiddendiv" );
+ $div.height( 30 ).height( function( i, height ) {
assert.equal( height, 30, "Make sure previous value is correct." );
return height + 1;
- });
+ } );
assert.equal( $div.height(), 31, "Make sure value was modified correctly." );
-});
+} );
-QUnit.test("innerWidth()", function( assert ) {
+QUnit.test( "innerWidth()", function( assert ) {
assert.expect( 6 );
var $div, div,
@@ -144,11 +144,11 @@ QUnit.test("innerWidth()", function( assert ) {
assert.equal( jQuery( document ).innerWidth(), $doc.width(), "Test on document" );
$div = jQuery( "#nothiddendiv" );
- $div.css({
+ $div.css( {
"margin": 10,
"border": "2px solid #fff",
"width": 30
- });
+ } );
assert.equal( $div.innerWidth(), 30, "Test with margin and border" );
$div.css( "padding", "20px" );
@@ -157,7 +157,7 @@ QUnit.test("innerWidth()", function( assert ) {
assert.equal( $div.innerWidth(), 70, "Test hidden div" );
// reset styles
- $div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
+ $div.css( { "display": "", "border": "", "padding": "", "width": "", "height": "" } );
div = jQuery( "
" );
@@ -166,9 +166,9 @@ QUnit.test("innerWidth()", function( assert ) {
div.remove();
QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
-QUnit.test("innerHeight()", function( assert ) {
+QUnit.test( "innerHeight()", function( assert ) {
assert.expect( 6 );
var $div, div,
@@ -179,11 +179,11 @@ QUnit.test("innerHeight()", function( assert ) {
assert.equal( jQuery( document ).innerHeight(), $doc.height(), "Test on document" );
$div = jQuery( "#nothiddendiv" );
- $div.css({
+ $div.css( {
"margin": 10,
"border": "2px solid #fff",
"height": 30
- });
+ } );
assert.equal( $div.innerHeight(), 30, "Test with margin and border" );
$div.css( "padding", "20px" );
@@ -192,7 +192,7 @@ QUnit.test("innerHeight()", function( assert ) {
assert.equal( $div.innerHeight(), 70, "Test hidden div" );
// reset styles
- $div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
+ $div.css( { "display": "", "border": "", "padding": "", "width": "", "height": "" } );
div = jQuery( "
" );
@@ -201,9 +201,9 @@ QUnit.test("innerHeight()", function( assert ) {
div.remove();
QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
-QUnit.test("outerWidth()", function( assert ) {
+QUnit.test( "outerWidth()", function( assert ) {
assert.expect( 11 );
var $div, div,
@@ -231,7 +231,7 @@ QUnit.test("outerWidth()", function( assert ) {
assert.equal( $div.outerWidth( true ), 94, "Test hidden div with padding, border and margin with margin option" );
// reset styles
- $div.css({ "position": "", "display": "", "border": "", "padding": "", "width": "", "height": "" });
+ $div.css( { "position": "", "display": "", "border": "", "padding": "", "width": "", "height": "" } );
div = jQuery( "
" );
@@ -240,23 +240,23 @@ QUnit.test("outerWidth()", function( assert ) {
div.remove();
QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
-QUnit.test("child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height() see #9441 #9300", function( assert ) {
- assert.expect(16);
+QUnit.test( "child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height() see #9441 #9300", function( assert ) {
+ assert.expect( 16 );
// setup html
- var $divNormal = jQuery("
").css({ "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" }),
+ var $divNormal = jQuery( "
" ).css( { "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" } ),
$divChild = $divNormal.clone(),
$divUnconnected = $divNormal.clone(),
- $divHiddenParent = jQuery("
").css( "display", "none" ).append( $divChild ).appendTo("body");
- $divNormal.appendTo("body");
+ $divHiddenParent = jQuery( "
" ).css( "display", "none" ).append( $divChild ).appendTo( "body" );
+ $divNormal.appendTo( "body" );
// tests that child div of a hidden div works the same as a normal div
assert.equal( $divChild.width(), $divNormal.width(), "child of a hidden element width() is wrong see #9441" );
assert.equal( $divChild.innerWidth(), $divNormal.innerWidth(), "child of a hidden element innerWidth() is wrong see #9441" );
assert.equal( $divChild.outerWidth(), $divNormal.outerWidth(), "child of a hidden element outerWidth() is wrong see #9441" );
- assert.equal( $divChild.outerWidth(true), $divNormal.outerWidth( true ), "child of a hidden element outerWidth( true ) is wrong see #9300" );
+ assert.equal( $divChild.outerWidth( true ), $divNormal.outerWidth( true ), "child of a hidden element outerWidth( true ) is wrong see #9300" );
// Support: IE 10-11, Edge
// Child height is not always decimal
@@ -269,7 +269,7 @@ QUnit.test("child of a hidden elem (or unconnected node) has accurate inner/oute
assert.equal( $divUnconnected.width(), $divNormal.width(), "unconnected element width() is wrong see #9441" );
assert.equal( $divUnconnected.innerWidth(), $divNormal.innerWidth(), "unconnected element innerWidth() is wrong see #9441" );
assert.equal( $divUnconnected.outerWidth(), $divNormal.outerWidth(), "unconnected element outerWidth() is wrong see #9441" );
- assert.equal( $divUnconnected.outerWidth(true), $divNormal.outerWidth( true ), "unconnected element outerWidth( true ) is wrong see #9300" );
+ assert.equal( $divUnconnected.outerWidth( true ), $divNormal.outerWidth( true ), "unconnected element outerWidth( true ) is wrong see #9300" );
// Support: IE 10-11, Edge
// Child height is not always decimal
@@ -281,9 +281,9 @@ QUnit.test("child of a hidden elem (or unconnected node) has accurate inner/oute
// teardown html
$divHiddenParent.remove();
$divNormal.remove();
-});
+} );
-QUnit.test("getting dimensions shouldn't modify runtimeStyle see #9233", function( assert ) {
+QUnit.test( "getting dimensions shouldn't modify runtimeStyle see #9233", function( assert ) {
assert.expect( 1 );
var $div = jQuery( "
" ).appendTo( "#qunit-fixture" ),
@@ -304,36 +304,36 @@ QUnit.test("getting dimensions shouldn't modify runtimeStyle see #9233", functio
}
$div.remove();
-});
+} );
QUnit.test( "table dimensions", function( assert ) {
assert.expect( 2 );
- var table = jQuery("
").appendTo("#qunit-fixture"),
- tdElem = table.find("td").first(),
- colElem = table.find("col").first().width( 300 );
+ var table = jQuery( "
" ).appendTo( "#qunit-fixture" ),
+ tdElem = table.find( "td" ).first(),
+ colElem = table.find( "col" ).first().width( 300 );
- table.find("td").css({ "margin": 0, "padding": 0 });
+ table.find( "td" ).css( { "margin": 0, "padding": 0 } );
assert.equal( tdElem.width(), tdElem.width(), "width() doesn't alter dimension values of empty cells, see #11293" );
assert.equal( colElem.width(), 300, "col elements have width(), see #12243" );
-});
+} );
-QUnit.test("box-sizing:border-box child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height() see #10413", function( assert ) {
- assert.expect(16);
+QUnit.test( "box-sizing:border-box child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height() see #10413", function( assert ) {
+ assert.expect( 16 );
// setup html
- var $divNormal = jQuery("
").css({ "boxSizing": "border-box", "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" }),
+ var $divNormal = jQuery( "
" ).css( { "boxSizing": "border-box", "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" } ),
$divChild = $divNormal.clone(),
$divUnconnected = $divNormal.clone(),
- $divHiddenParent = jQuery("
").css( "display", "none" ).append( $divChild ).appendTo("body");
- $divNormal.appendTo("body");
+ $divHiddenParent = jQuery( "
" ).css( "display", "none" ).append( $divChild ).appendTo( "body" );
+ $divNormal.appendTo( "body" );
// tests that child div of a hidden div works the same as a normal div
assert.equal( $divChild.width(), $divNormal.width(), "child of a hidden element width() is wrong see #10413" );
assert.equal( $divChild.innerWidth(), $divNormal.innerWidth(), "child of a hidden element innerWidth() is wrong see #10413" );
assert.equal( $divChild.outerWidth(), $divNormal.outerWidth(), "child of a hidden element outerWidth() is wrong see #10413" );
- assert.equal( $divChild.outerWidth(true), $divNormal.outerWidth( true ), "child of a hidden element outerWidth( true ) is wrong see #10413" );
+ assert.equal( $divChild.outerWidth( true ), $divNormal.outerWidth( true ), "child of a hidden element outerWidth( true ) is wrong see #10413" );
// Support: IE 10-11, Edge
// Child height is not always decimal
@@ -346,7 +346,7 @@ QUnit.test("box-sizing:border-box child of a hidden elem (or unconnected node) h
assert.equal( $divUnconnected.width(), $divNormal.width(), "unconnected element width() is wrong see #10413" );
assert.equal( $divUnconnected.innerWidth(), $divNormal.innerWidth(), "unconnected element innerWidth() is wrong see #10413" );
assert.equal( $divUnconnected.outerWidth(), $divNormal.outerWidth(), "unconnected element outerWidth() is wrong see #10413" );
- assert.equal( $divUnconnected.outerWidth(true), $divNormal.outerWidth( true ), "unconnected element outerWidth( true ) is wrong see #10413" );
+ assert.equal( $divUnconnected.outerWidth( true ), $divNormal.outerWidth( true ), "unconnected element outerWidth( true ) is wrong see #10413" );
// Support: IE 10-11, Edge
// Child height is not always decimal
@@ -358,9 +358,9 @@ QUnit.test("box-sizing:border-box child of a hidden elem (or unconnected node) h
// teardown html
$divHiddenParent.remove();
$divNormal.remove();
-});
+} );
-QUnit.test("outerHeight()", function( assert ) {
+QUnit.test( "outerHeight()", function( assert ) {
assert.expect( 11 );
var $div, div,
@@ -387,7 +387,7 @@ QUnit.test("outerHeight()", function( assert ) {
assert.equal( $div.outerHeight( true ), 94, "Test hidden div with padding, border and margin with margin option" );
// reset styles
- $div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
+ $div.css( { "display": "", "border": "", "padding": "", "width": "", "height": "" } );
div = jQuery( "
" );
@@ -396,20 +396,20 @@ QUnit.test("outerHeight()", function( assert ) {
div.remove();
QUnit.expectJqData( this, $div[ 0 ], "olddisplay" );
-});
+} );
-QUnit.test("passing undefined is a setter #5571", function( assert ) {
- assert.expect(4);
- assert.equal(jQuery("#nothiddendiv").height(30).height(undefined).height(), 30, ".height(undefined) is chainable (#5571)");
- assert.equal(jQuery("#nothiddendiv").height(30).innerHeight(undefined).height(), 30, ".innerHeight(undefined) is chainable (#5571)");
- assert.equal(jQuery("#nothiddendiv").height(30).outerHeight(undefined).height(), 30, ".outerHeight(undefined) is chainable (#5571)");
- assert.equal(jQuery("#nothiddendiv").width(30).width(undefined).width(), 30, ".width(undefined) is chainable (#5571)");
-});
+QUnit.test( "passing undefined is a setter #5571", function( assert ) {
+ assert.expect( 4 );
+ assert.equal( jQuery( "#nothiddendiv" ).height( 30 ).height( undefined ).height(), 30, ".height(undefined) is chainable (#5571)" );
+ assert.equal( jQuery( "#nothiddendiv" ).height( 30 ).innerHeight( undefined ).height(), 30, ".innerHeight(undefined) is chainable (#5571)" );
+ assert.equal( jQuery( "#nothiddendiv" ).height( 30 ).outerHeight( undefined ).height(), 30, ".outerHeight(undefined) is chainable (#5571)" );
+ assert.equal( jQuery( "#nothiddendiv" ).width( 30 ).width( undefined ).width(), 30, ".width(undefined) is chainable (#5571)" );
+} );
QUnit.test( "getters on non elements should return null", function( assert ) {
assert.expect( 8 );
- var nonElem = jQuery("notAnElement");
+ var nonElem = jQuery( "notAnElement" );
assert.strictEqual( nonElem.width(), null, ".width() is not null (#12283)" );
assert.strictEqual( nonElem.innerWidth(), null, ".innerWidth() is not null (#12283)" );
@@ -420,14 +420,14 @@ QUnit.test( "getters on non elements should return null", function( assert ) {
assert.strictEqual( nonElem.innerHeight(), null, ".innerHeight() is not null (#12283)" );
assert.strictEqual( nonElem.outerHeight(), null, ".outerHeight() is not null (#12283)" );
assert.strictEqual( nonElem.outerHeight( true ), null, ".outerHeight(true) is not null (#12283)" );
-});
+} );
-QUnit.test("setters with and without box-sizing:border-box", function( assert ){
- assert.expect(20);
+QUnit.test( "setters with and without box-sizing:border-box", function( assert ) {
+ assert.expect( 20 );
// Support: Android 2.3 (-webkit-box-sizing).
- var el_bb = jQuery("
test
").appendTo("#qunit-fixture"),
- el = jQuery("
test
").appendTo("#qunit-fixture"),
+ var el_bb = jQuery( "
test
" ).appendTo( "#qunit-fixture" ),
+ el = jQuery( "
test
" ).appendTo( "#qunit-fixture" ),
expected = 100;
assert.equal( el_bb.width( 101 ).width(), expected + 1, "test border-box width(int) by roundtripping" );
@@ -453,13 +453,13 @@ QUnit.test("setters with and without box-sizing:border-box", function( assert ){
assert.equal( el.outerHeight( 117 ).height(), expected + 3, "test border-box outerHeight(int) by roundtripping" );
assert.equal( el.outerHeight( 118, false ).height(), expected + 4, "test border-box outerHeight(int, false) by roundtripping" );
assert.equal( el.outerHeight( 129, true ).height(), expected + 5, "test border-box innerHeight(int, true) by roundtripping" );
-});
+} );
testIframe(
"dimensions/documentLarge",
"window vs. large document",
function( jQuery, window, document, assert ) {
- assert.expect(2);
+ assert.expect( 2 );
assert.ok( jQuery( document ).height() > jQuery( window ).height(), "document height is larger than window height" );
assert.ok( jQuery( document ).width() > jQuery( window ).width(), "document width is larger than window width" );
@@ -472,15 +472,15 @@ QUnit.test( "allow modification of coordinates argument (gh-1848)", function( as
var offsetTop,
element = jQuery( "
" ).appendTo( "#qunit-fixture" );
- element.offset(function( index, coords ) {
+ element.offset( function( index, coords ) {
coords.top = 100;
return coords;
- });
+ } );
offsetTop = element.offset().top;
- assert.ok( Math.abs(offsetTop - 100) < 0.02,
- "coordinates are modified (got offset.top: " + offsetTop + ")");
-});
+ assert.ok( Math.abs( offsetTop - 100 ) < 0.02,
+ "coordinates are modified (got offset.top: " + offsetTop + ")" );
+} );
-})();
+} )();
diff --git a/test/unit/effects.js b/test/unit/effects.js
index 934b3e193..755b074f8 100644
--- a/test/unit/effects.js
+++ b/test/unit/effects.js
@@ -1,4 +1,4 @@
-(function() {
+( function() {
// Can't test what ain't there
if ( !jQuery.fx ) {
@@ -7,7 +7,7 @@ if ( !jQuery.fx ) {
var oldRaf = window.requestAnimationFrame;
-QUnit.module("effects", {
+QUnit.module( "effects", {
setup: function() {
window.requestAnimationFrame = null;
this.sandbox = sinon.sandbox.create();
@@ -25,44 +25,44 @@ QUnit.module("effects", {
window.requestAnimationFrame = oldRaf;
return moduleTeardown.apply( this, arguments );
}
-});
+} );
-QUnit.test("sanity check", function( assert ) {
- assert.expect(1);
- assert.equal( jQuery("#dl:visible, #qunit-fixture:visible, #foo:visible").length, 3, "QUnit state is correct for testing effects" );
-});
+QUnit.test( "sanity check", function( assert ) {
+ assert.expect( 1 );
+ assert.equal( jQuery( "#dl:visible, #qunit-fixture:visible, #foo:visible" ).length, 3, "QUnit state is correct for testing effects" );
+} );
-QUnit.test("show() basic", function( assert ) {
+QUnit.test( "show() basic", function( assert ) {
assert.expect( 1 );
- var div = jQuery("
").hide().appendTo("#qunit-fixture").show();
+ var div = jQuery( "
" ).hide().appendTo( "#qunit-fixture" ).show();
- assert.equal( div.css("display"), "block", "Make sure pre-hidden divs show" );
+ assert.equal( div.css( "display" ), "block", "Make sure pre-hidden divs show" );
// Clean up the detached node
div.remove();
-});
+} );
-QUnit.test("show()", function( assert ) {
+QUnit.test( "show()", function( assert ) {
assert.expect( 27 );
var div, speeds, old, test,
- hiddendiv = jQuery("div.hidden");
+ hiddendiv = jQuery( "div.hidden" );
- assert.equal(jQuery.css( hiddendiv[0], "display"), "none", "hiddendiv is display: none");
+ assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "none", "hiddendiv is display: none" );
- hiddendiv.css("display", "block");
- assert.equal(jQuery.css( hiddendiv[0], "display"), "block", "hiddendiv is display: block");
+ hiddendiv.css( "display", "block" );
+ assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "block", "hiddendiv is display: block" );
hiddendiv.show();
- assert.equal(jQuery.css( hiddendiv[0], "display"), "block", "hiddendiv is display: block");
+ assert.equal( jQuery.css( hiddendiv[ 0 ], "display" ), "block", "hiddendiv is display: block" );
- hiddendiv.css("display","");
+ hiddendiv.css( "display", "" );
- div = jQuery("#fx-queue div").slice(0, 4);
- div.show().each(function() {
- assert.notEqual(this.style.display, "none", "don't change any
with display block");
- });
+ div = jQuery( "#fx-queue div" ).slice( 0, 4 );
+ div.show().each( function() {
+ assert.notEqual( this.style.display, "none", "don't change any
with display block" );
+ } );
speeds = {
"null speed": null,
@@ -70,23 +70,23 @@ QUnit.test("show()", function( assert ) {
"false speed": false
};
- jQuery.each(speeds, function(name, speed) {
+ jQuery.each( speeds, function( name, speed ) {
var pass = true;
- div.hide().show(speed).each(function() {
+ div.hide().show( speed ).each( function() {
if ( this.style.display === "none" ) {
pass = false;
}
- });
- assert.ok( pass, "Show with " + name);
- });
+ } );
+ assert.ok( pass, "Show with " + name );
+ } );
- jQuery.each(speeds, function(name, speed) {
+ jQuery.each( speeds, function( name, speed ) {
var pass = true;
- div.hide().show(speed, function() {
+ div.hide().show( speed, function() {
pass = false;
- });
+ } );
assert.ok( pass, "Show with " + name + " does not call animate callback" );
- });
+ } );
// Tolerate data from show()/hide()
QUnit.expectJqData( this, div, "olddisplay" );
@@ -99,40 +99,40 @@ QUnit.test("show()", function( assert ) {
"
"
).appendTo( "#qunit-fixture" ).find( "*" ).css( "display", "none" );
- old = jQuery("#test-table").show().css("display") !== "table";
- jQuery("#test-table").remove();
+ old = jQuery( "#test-table" ).show().css( "display" ) !== "table";
+ jQuery( "#test-table" ).remove();
test = {
- "div" : "block",
- "p" : "block",
- "a" : "inline",
- "code" : "inline",
- "pre" : "block",
- "span" : "inline",
- "table" : old ? "block" : "table",
- "thead" : old ? "block" : "table-header-group",
- "tbody" : old ? "block" : "table-row-group",
- "tr" : old ? "block" : "table-row",
- "th" : old ? "block" : "table-cell",
- "td" : old ? "block" : "table-cell",
- "ul" : "block",
- "li" : old ? "block" : "list-item"
+ "div": "block",
+ "p": "block",
+ "a": "inline",
+ "code": "inline",
+ "pre": "block",
+ "span": "inline",
+ "table": old ? "block" : "table",
+ "thead": old ? "block" : "table-header-group",
+ "tbody": old ? "block" : "table-row-group",
+ "tr": old ? "block" : "table-row",
+ "th": old ? "block" : "table-cell",
+ "td": old ? "block" : "table-cell",
+ "ul": "block",
+ "li": old ? "block" : "list-item"
};
- jQuery.each(test, function(selector, expected) {
- var elem = jQuery(selector, "#show-tests").show();
- assert.equal( elem.css("display"), expected, "Show using correct display type for " + selector );
- });
+ jQuery.each( test, function( selector, expected ) {
+ var elem = jQuery( selector, "#show-tests" ).show();
+ assert.equal( elem.css( "display" ), expected, "Show using correct display type for " + selector );
+ } );
- jQuery("#show-tests").remove();
+ jQuery( "#show-tests" ).remove();
// Make sure that showing or hiding a text node doesn't cause an error
- jQuery("
test
text
test ").show().remove();
- jQuery("
test
text
test ").hide().remove();
-});
+ jQuery( "
test
text
test " ).show().remove();
+ jQuery( "
test
text
test " ).hide().remove();
+} );
-QUnit.test("show(Number) - other displays", function( assert ) {
- assert.expect(30);
+QUnit.test( "show(Number) - other displays", function( assert ) {
+ assert.expect( 30 );
jQuery(
"
" +
@@ -143,105 +143,105 @@ QUnit.test("show(Number) - other displays", function( assert ) {
).appendTo( "#qunit-fixture" ).find( "*" ).css( "display", "none" );
var test,
- old = jQuery("#test-table").show().css("display") !== "table";
+ old = jQuery( "#test-table" ).show().css( "display" ) !== "table";
- jQuery("#test-table").remove();
+ jQuery( "#test-table" ).remove();
// Note: inline elements are expected to be inline-block
// because we're showing width/height
// Can't animate width/height inline
// See #14344
test = {
- "div" : "block",
- "p" : "block",
- "a" : "inline",
- "code" : "inline",
- "pre" : "block",
- "span" : "inline",
- "table" : old ? "block" : "table",
- "thead" : old ? "block" : "table-header-group",
- "tbody" : old ? "block" : "table-row-group",
- "tr" : old ? "block" : "table-row",
- "th" : old ? "block" : "table-cell",
- "td" : old ? "block" : "table-cell",
- "ul" : "block",
- "li" : old ? "block" : "list-item"
+ "div": "block",
+ "p": "block",
+ "a": "inline",
+ "code": "inline",
+ "pre": "block",
+ "span": "inline",
+ "table": old ? "block" : "table",
+ "thead": old ? "block" : "table-header-group",
+ "tbody": old ? "block" : "table-row-group",
+ "tr": old ? "block" : "table-row",
+ "th": old ? "block" : "table-cell",
+ "td": old ? "block" : "table-cell",
+ "ul": "block",
+ "li": old ? "block" : "list-item"
};
jQuery.each( test, function( selector ) {
jQuery( selector, "#show-tests" ).show( 100 );
- });
+ } );
this.clock.tick( 50 );
jQuery.each( test, function( selector, expected ) {
- jQuery( selector, "#show-tests" ).each(function() {
+ jQuery( selector, "#show-tests" ).each( function() {
assert.equal(
jQuery( this ).css( "display" ),
expected === "inline" ? "inline-block" : expected,
"Correct display type during animation for " + selector
);
- });
- });
+ } );
+ } );
this.clock.tick( 50 );
jQuery.each( test, function( selector, expected ) {
- jQuery( selector, "#show-tests" ).each(function() {
+ jQuery( selector, "#show-tests" ).each( function() {
assert.equal( jQuery( this ).css( "display" ), expected,
"Correct display type after animation for " + selector );
- });
- });
+ } );
+ } );
- jQuery("#show-tests").remove();
-});
+ jQuery( "#show-tests" ).remove();
+} );
// Supports #7397
-QUnit.test("Persist correct display value", function( assert ) {
- assert.expect(3);
+QUnit.test( "Persist correct display value", function( assert ) {
+ assert.expect( 3 );
jQuery( "
foo
" )
.appendTo( "#qunit-fixture" ).find( "*" ).css( "display", "none" );
- var $span = jQuery("#show-tests span"),
- displayNone = $span.css("display"),
+ var $span = jQuery( "#show-tests span" ),
+ displayNone = $span.css( "display" ),
display = "",
clock = this.clock;
$span.show();
- display = $span.css("display");
+ display = $span.css( "display" );
$span.hide();
- $span.fadeIn(100, function() {
- assert.equal($span.css("display"), display, "Expecting display: " + display);
- $span.fadeOut(100, function () {
- assert.equal($span.css("display"), displayNone, "Expecting display: " + displayNone);
- $span.fadeIn(100, function() {
- assert.equal($span.css("display"), display, "Expecting display: " + display);
- });
- });
- });
+ $span.fadeIn( 100, function() {
+ assert.equal( $span.css( "display" ), display, "Expecting display: " + display );
+ $span.fadeOut( 100, function() {
+ assert.equal( $span.css( "display" ), displayNone, "Expecting display: " + displayNone );
+ $span.fadeIn( 100, function() {
+ assert.equal( $span.css( "display" ), display, "Expecting display: " + display );
+ } );
+ } );
+ } );
clock.tick( 300 );
QUnit.expectJqData( this, $span, "olddisplay" );
-});
+} );
-QUnit.test("animate(Hash, Object, Function)", function( assert ) {
- assert.expect(1);
- var hash = {opacity: "show"},
- hashCopy = jQuery.extend({}, hash);
- jQuery("#foo").animate(hash, 0, function() {
+QUnit.test( "animate(Hash, Object, Function)", function( assert ) {
+ assert.expect( 1 );
+ var hash = { opacity: "show" },
+ hashCopy = jQuery.extend( {}, hash );
+ jQuery( "#foo" ).animate( hash, 0, function() {
assert.equal( hash.opacity, hashCopy.opacity, "Check if animate changed the hash parameter" );
- });
-});
+ } );
+} );
-QUnit.test("animate relative values", function( assert ) {
+QUnit.test( "animate relative values", function( assert ) {
var value = 40,
clock = this.clock,
bases = [ "%", "px", "em" ],
adjustments = [ "px", "em" ],
- container = jQuery("
")
- .css({ position: "absolute", height: "50em", width: "50em" }),
+ container = jQuery( "
" )
+ .css( { position: "absolute", height: "50em", width: "50em" } ),
animations = bases.length * adjustments.length;
assert.expect( 2 * animations );
@@ -250,13 +250,13 @@ QUnit.test("animate relative values", function( assert ) {
jQuery.each( adjustments, function( _, adjustUnit ) {
var base = value + baseUnit,
adjust = { height: "+=2" + adjustUnit, width: "-=2" + adjustUnit },
- elem = jQuery("
")
- .appendTo( container.clone().appendTo("#qunit-fixture") )
- .css({
+ elem = jQuery( "
" )
+ .appendTo( container.clone().appendTo( "#qunit-fixture" ) )
+ .css( {
position: "absolute",
height: base,
width: value + adjustUnit
- }),
+ } ),
baseScale = elem[ 0 ].offsetHeight / value,
adjustScale = elem[ 0 ].offsetWidth / value;
@@ -266,80 +266,79 @@ QUnit.test("animate relative values", function( assert ) {
assert.equal( this.offsetWidth, value * baseScale - 2 * adjustScale,
baseUnit + "-=" + adjustUnit );
- });
+ } );
clock.tick( 100 );
- });
- });
-});
+ } );
+ } );
+} );
-QUnit.test("animate negative height", function( assert ) {
- assert.expect(1);
- jQuery("#foo").animate({ height: -100 }, 100, function() {
+QUnit.test( "animate negative height", function( assert ) {
+ assert.expect( 1 );
+ jQuery( "#foo" ).animate( { height: -100 }, 100, function() {
assert.equal( this.offsetHeight, 0, "Verify height." );
- });
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate negative margin", function( assert ) {
- assert.expect(1);
- jQuery("#foo").animate({ "marginTop": -100 }, 100, function() {
- assert.equal( jQuery(this).css("marginTop"), "-100px", "Verify margin." );
- });
+QUnit.test( "animate negative margin", function( assert ) {
+ assert.expect( 1 );
+ jQuery( "#foo" ).animate( { "marginTop": -100 }, 100, function() {
+ assert.equal( jQuery( this ).css( "marginTop" ), "-100px", "Verify margin." );
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate negative margin with px", function( assert ) {
- assert.expect(1);
- jQuery("#foo").animate({ marginTop: "-100px" }, 100, function() {
- assert.equal( jQuery(this).css("marginTop"), "-100px", "Verify margin." );
- });
+QUnit.test( "animate negative margin with px", function( assert ) {
+ assert.expect( 1 );
+ jQuery( "#foo" ).animate( { marginTop: "-100px" }, 100, function() {
+ assert.equal( jQuery( this ).css( "marginTop" ), "-100px", "Verify margin." );
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate negative padding", function( assert ) {
- assert.expect(1);
- jQuery("#foo").animate({ "paddingBottom": -100 }, 100, function() {
- assert.equal( jQuery(this).css("paddingBottom"), "0px", "Verify paddingBottom." );
- });
+QUnit.test( "animate negative padding", function( assert ) {
+ assert.expect( 1 );
+ jQuery( "#foo" ).animate( { "paddingBottom": -100 }, 100, function() {
+ assert.equal( jQuery( this ).css( "paddingBottom" ), "0px", "Verify paddingBottom." );
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate block as inline width/height", function( assert ) {
- assert.expect(3);
+QUnit.test( "animate block as inline width/height", function( assert ) {
+ assert.expect( 3 );
-
- jQuery("#foo").css({ display: "inline", width: "", height: "" }).animate({ width: 42, height: 42 }, 100, function() {
- assert.equal( jQuery(this).css("display"), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
+ jQuery( "#foo" ).css( { display: "inline", width: "", height: "" } ).animate( { width: 42, height: 42 }, 100, function() {
+ assert.equal( jQuery( this ).css( "display" ), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
assert.equal( this.offsetWidth, 42, "width was animated" );
assert.equal( this.offsetHeight, 42, "height was animated" );
- });
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate native inline width/height", function( assert ) {
- assert.expect(3);
+QUnit.test( "animate native inline width/height", function( assert ) {
+ assert.expect( 3 );
- jQuery("#foo").css({ display: "", width: "", height: "" })
- .append("
text ")
- .children("span")
- .animate({ width: 42, height: 42 }, 100, function() {
- assert.equal( jQuery(this).css("display"), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
+ jQuery( "#foo" ).css( { display: "", width: "", height: "" } )
+ .append( "
text " )
+ .children( "span" )
+ .animate( { width: 42, height: 42 }, 100, function() {
+ assert.equal( jQuery( this ).css( "display" ), "inline-block", "inline-block was set on non-floated inline element when animating width/height" );
assert.equal( this.offsetWidth, 42, "width was animated" );
assert.equal( this.offsetHeight, 42, "height was animated" );
- });
+ } );
this.clock.tick( 100 );
-});
+} );
QUnit.test( "animate block width/height", function( assert ) {
assert.expect( 3 );
- jQuery("
").appendTo("#qunit-fixture").css({
+ jQuery( "
" ).appendTo( "#qunit-fixture" ).css( {
display: "block",
width: 20,
height: 20,
paddingLeft: 60
- }).animate({
+ } ).animate( {
width: 42,
height: 42
}, {
@@ -350,80 +349,80 @@ QUnit.test( "animate block width/height", function( assert ) {
}
},
complete: function() {
- assert.equal( jQuery( this ).css("display"), "block", "inline-block was not set on block element when animating width/height" );
+ assert.equal( jQuery( this ).css( "display" ), "block", "inline-block was not set on block element when animating width/height" );
assert.equal( jQuery( this ).width(), 42, "width was animated" );
assert.equal( jQuery( this ).height(), 42, "height was animated" );
}
- });
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate table width/height", function( assert ) {
- assert.expect(1);
+QUnit.test( "animate table width/height", function( assert ) {
+ assert.expect( 1 );
- var displayMode = jQuery("#table").css("display") !== "table" ? "block" : "table";
+ var displayMode = jQuery( "#table" ).css( "display" ) !== "table" ? "block" : "table";
- jQuery("#table").animate({ width: 42, height: 42 }, 100, function() {
- assert.equal( jQuery(this).css("display"), displayMode, "display mode is correct" );
- });
+ jQuery( "#table" ).animate( { width: 42, height: 42 }, 100, function() {
+ assert.equal( jQuery( this ).css( "display" ), displayMode, "display mode is correct" );
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate table-row width/height", function( assert ) {
- assert.expect(3);
+QUnit.test( "animate table-row width/height", function( assert ) {
+ assert.expect( 3 );
var tr = jQuery( "#table" )
- .attr({ "cellspacing": 0, "cellpadding": 0, "border": 0 })
+ .attr( { "cellspacing": 0, "cellpadding": 0, "border": 0 } )
.html( "
" )
.find( "tr" );
- tr.animate({ width: 10, height: 10 }, 100, function() {
+ tr.animate( { width: 10, height: 10 }, 100, function() {
assert.equal( jQuery( this ).css( "display" ), "table-row", "display mode is correct" );
assert.equal( this.offsetWidth, 20, "width animated to shrink wrap point" );
assert.equal( this.offsetHeight, 20, "height animated to shrink wrap point" );
- });
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate table-cell width/height", function( assert ) {
- assert.expect(3);
+QUnit.test( "animate table-cell width/height", function( assert ) {
+ assert.expect( 3 );
var td = jQuery( "#table" )
- .attr({ "cellspacing": 0, "cellpadding": 0, "border": 0 })
+ .attr( { "cellspacing": 0, "cellpadding": 0, "border": 0 } )
.html( "
" )
.find( "td" );
- td.animate({ width: 10, height: 10 }, 100, function() {
+ td.animate( { width: 10, height: 10 }, 100, function() {
assert.equal( jQuery( this ).css( "display" ), "table-cell", "display mode is correct" );
assert.equal( this.offsetWidth, 20, "width animated to shrink wrap point" );
assert.equal( this.offsetHeight, 20, "height animated to shrink wrap point" );
- });
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("animate percentage(%) on width/height", function( assert ) {
+QUnit.test( "animate percentage(%) on width/height", function( assert ) {
assert.expect( 2 );
- var $div = jQuery("
")
- .appendTo("#qunit-fixture").children("div");
+ var $div = jQuery( "
" )
+ .appendTo( "#qunit-fixture" ).children( "div" );
- $div.animate({ width: "25%", height: "25%" }, 13, function() {
- var $this = jQuery(this);
- assert.equal( $this.css("width"), "15px", "Width was animated to 15px rather than 25px");
- assert.equal( $this.css("height"), "15px", "Height was animated to 15px rather than 25px");
- });
+ $div.animate( { width: "25%", height: "25%" }, 13, function() {
+ var $this = jQuery( this );
+ assert.equal( $this.css( "width" ), "15px", "Width was animated to 15px rather than 25px" );
+ assert.equal( $this.css( "height" ), "15px", "Height was animated to 15px rather than 25px" );
+ } );
this.clock.tick( 20 );
-});
+} );
-QUnit.test("animate resets overflow-x and overflow-y when finished", function( assert ) {
- assert.expect(2);
- jQuery("#foo")
- .css({ display: "block", width: 20, height: 20, overflowX: "visible", overflowY: "auto" })
- .animate({ width: 42, height: 42 }, 100, function() {
+QUnit.test( "animate resets overflow-x and overflow-y when finished", function( assert ) {
+ assert.expect( 2 );
+ jQuery( "#foo" )
+ .css( { display: "block", width: 20, height: 20, overflowX: "visible", overflowY: "auto" } )
+ .animate( { width: 42, height: 42 }, 100, function() {
assert.equal( this.style.overflowX, "visible", "overflow-x is visible" );
assert.equal( this.style.overflowY, "auto", "overflow-y is auto" );
- });
+ } );
this.clock.tick( 100 );
-});
+} );
/* // This test ends up being flaky depending upon the CPU load
QUnit.test("animate option (queue === false)", function( assert ) {
@@ -450,7 +449,7 @@ QUnit.test( "animate option { queue: false }", function( assert ) {
assert.expect( 2 );
var foo = jQuery( "#foo" );
- foo.animate({
+ foo.animate( {
fontSize: "2em"
}, {
queue: false,
@@ -458,17 +457,17 @@ QUnit.test( "animate option { queue: false }", function( assert ) {
complete: function() {
assert.ok( true, "Animation Completed" );
}
- });
+ } );
this.clock.tick( 10 );
assert.equal( foo.queue().length, 0, "Queue is empty" );
-});
+} );
QUnit.test( "animate option { queue: true }", function( assert ) {
assert.expect( 2 );
var foo = jQuery( "#foo" );
- foo.animate({
+ foo.animate( {
fontSize: "2em"
}, {
queue: true,
@@ -476,18 +475,18 @@ QUnit.test( "animate option { queue: true }", function( assert ) {
complete: function() {
assert.ok( true, "Animation Completed" );
}
- });
+ } );
assert.notEqual( foo.queue().length, 0, "Default queue is not empty" );
//clear out existing timers before next test
this.clock.tick( 10 );
-});
+} );
QUnit.test( "animate option { queue: 'name' }", function( assert ) {
assert.expect( 5 );
var foo = jQuery( "#foo" ),
- origWidth = parseFloat( foo.css("width") ),
+ origWidth = parseFloat( foo.css( "width" ) ),
order = [];
foo.animate( { width: origWidth + 100 }, {
@@ -497,128 +496,127 @@ QUnit.test( "animate option { queue: 'name' }", function( assert ) {
// second callback function
order.push( 2 );
- assert.equal( parseFloat( foo.css("width") ), origWidth + 100, "Animation ended" );
- assert.equal( foo.queue("name").length, 1, "Queue length of 'name' queue" );
+ assert.equal( parseFloat( foo.css( "width" ) ), origWidth + 100, "Animation ended" );
+ assert.equal( foo.queue( "name" ).length, 1, "Queue length of 'name' queue" );
}
- }).queue( "name", function() {
+ } ).queue( "name", function() {
// last callback function
assert.deepEqual( order, [ 1, 2 ], "Callbacks in expected order" );
- });
-
+ } );
// this is the first callback function that should be called
order.push( 1 );
- assert.equal( parseFloat( foo.css("width") ), origWidth, "Animation does not start on its own." );
- assert.equal( foo.queue("name").length, 2, "Queue length of 'name' queue" );
+ assert.equal( parseFloat( foo.css( "width" ) ), origWidth, "Animation does not start on its own." );
+ assert.equal( foo.queue( "name" ).length, 2, "Queue length of 'name' queue" );
foo.dequeue( "name" );
this.clock.tick( 10 );
-});
+} );
-QUnit.test("animate with no properties", function( assert ) {
- assert.expect(2);
+QUnit.test( "animate with no properties", function( assert ) {
+ assert.expect( 2 );
var foo,
- divs = jQuery("div"),
+ divs = jQuery( "div" ),
count = 0;
- divs.animate({}, function(){
+ divs.animate( {}, function() {
count++;
- });
+ } );
assert.equal( divs.length, count, "Make sure that callback is called for each element in the set." );
+ foo = jQuery( "#foo" );
- foo = jQuery("#foo");
-
- foo.animate({});
- foo.animate({top: 10}, 100, function(){
+ foo.animate( {} );
+ foo.animate( { top: 10 }, 100, function() {
assert.ok( true, "Animation was properly dequeued." );
- });
+ } );
this.clock.tick( 100 );
-});
-
-QUnit.test("animate duration 0", function( assert ) {
- assert.expect(11);
+} );
+QUnit.test( "animate duration 0", function( assert ) {
+ assert.expect( 11 );
var $elem,
- $elems = jQuery([{ a:0 },{ a:0 }]),
+ $elems = jQuery( [ { a:0 },{ a:0 } ] ),
counter = 0;
assert.equal( jQuery.timers.length, 0, "Make sure no animation was running from another test" );
- $elems.eq(0).animate( {a:1}, 0, function(){
+ $elems.eq( 0 ).animate( { a:1 }, 0, function() {
assert.ok( true, "Animate a simple property." );
counter++;
- });
+ } );
// Failed until [6115]
assert.equal( jQuery.timers.length, 0, "Make sure synchronic animations are not left on jQuery.timers" );
assert.equal( counter, 1, "One synchronic animations" );
- $elems.animate( { a:2 }, 0, function(){
+ $elems.animate( { a:2 }, 0, function() {
assert.ok( true, "Animate a second simple property." );
counter++;
- });
+ } );
assert.equal( counter, 3, "Multiple synchronic animations" );
- $elems.eq(0).animate( {a:3}, 0, function(){
+ $elems.eq( 0 ).animate( { a:3 }, 0, function() {
assert.ok( true, "Animate a third simple property." );
counter++;
- });
- $elems.eq(1).animate( {a:3}, 200, function(){
+ } );
+ $elems.eq( 1 ).animate( { a:3 }, 200, function() {
counter++;
+
// Failed until [6115]
assert.equal( counter, 5, "One synchronic and one asynchronic" );
- });
+ } );
this.clock.tick( 200 );
- $elem = jQuery("
");
- $elem.show(0, function(){
- assert.ok(true, "Show callback with no duration");
- });
- $elem.hide(0, function(){
- assert.ok(true, "Hide callback with no duration");
- });
+ $elem = jQuery( "
" );
+ $elem.show( 0, function() {
+ assert.ok( true, "Show callback with no duration" );
+ } );
+ $elem.hide( 0, function() {
+ assert.ok( true, "Hide callback with no duration" );
+ } );
// manually clean up detached elements
$elem.remove();
-});
+} );
-QUnit.test("animate hyphenated properties", function( assert ) {
- assert.expect(1);
+QUnit.test( "animate hyphenated properties", function( assert ) {
+ assert.expect( 1 );
- jQuery("#foo")
- .css("font-size", 10)
- .animate({"font-size": 20}, 200, function() {
+ jQuery( "#foo" )
+ .css( "font-size", 10 )
+ .animate( { "font-size": 20 }, 200, function() {
assert.equal( this.style.fontSize, "20px", "The font-size property was animated." );
- });
+ } );
+
// FIXME why is this double only when run with other tests
this.clock.tick( 400 );
-});
+} );
-QUnit.test("animate non-element", function( assert ) {
- assert.expect(1);
+QUnit.test( "animate non-element", function( assert ) {
+ assert.expect( 1 );
var obj = { test: 0 };
- jQuery(obj).animate({test: 200}, 200, function(){
+ jQuery( obj ).animate( { test: 200 }, 200, function() {
assert.equal( obj.test, 200, "The custom property should be modified." );
- });
+ } );
this.clock.tick( 200 );
-});
+} );
-QUnit.test("stop()", function( assert ) {
+QUnit.test( "stop()", function( assert ) {
assert.expect( 4 );
var $one, $two,
- $foo = jQuery("#foo"),
+ $foo = jQuery( "#foo" ),
w = 0,
nw;
@@ -626,34 +624,35 @@ QUnit.test("stop()", function( assert ) {
.animate( { "width": "show" }, 1500 );
this.clock.tick( 100 );
- nw = $foo.css("width");
+ nw = $foo.css( "width" );
assert.notEqual( parseFloat( nw ), w, "An animation occurred " + nw + " " + w + "px" );
$foo.stop();
- nw = $foo.css("width");
+ nw = $foo.css( "width" );
assert.notEqual( parseFloat( nw ), w, "Stop didn't reset the animation " + nw + " " + w + "px" );
this.clock.tick( 100 );
$foo.removeData();
- $foo.removeData(undefined, true);
- assert.equal( nw, $foo.css("width"), "The animation didn't continue" );
+ $foo.removeData( undefined, true );
+ assert.equal( nw, $foo.css( "width" ), "The animation didn't continue" );
- $one = jQuery("#fadein");
- $two = jQuery("#show");
- $one.fadeTo(100, 0, function() {
+ $one = jQuery( "#fadein" );
+ $two = jQuery( "#show" );
+ $one.fadeTo( 100, 0, function() {
$one.stop();
- });
+ } );
this.clock.tick( 100 );
- $two.fadeTo(100, 0, function() {
- assert.equal( $two.css("opacity"), "0", "Stop does not interfere with animations on other elements (#6641)" );
- // Reset styles
- $one.add( $two ).css("opacity", "");
- });
- this.clock.tick( 100 );
-});
+ $two.fadeTo( 100, 0, function() {
+ assert.equal( $two.css( "opacity" ), "0", "Stop does not interfere with animations on other elements (#6641)" );
-QUnit.test("stop() - several in queue", function( assert ) {
+ // Reset styles
+ $one.add( $two ).css( "opacity", "" );
+ } );
+ this.clock.tick( 100 );
+} );
+
+QUnit.test( "stop() - several in queue", function( assert ) {
assert.expect( 5 );
var nw, $foo = jQuery( "#foo" );
@@ -661,9 +660,9 @@ QUnit.test("stop() - several in queue", function( assert ) {
// default duration is 400ms, so 800px ensures we aren't 0 or 1 after 1ms
$foo.hide().css( "width", 800 );
- $foo.animate({ "width": "show" }, 400, "linear");
- $foo.animate({ "width": "hide" });
- $foo.animate({ "width": "show" });
+ $foo.animate( { "width": "show" }, 400, "linear" );
+ $foo.animate( { "width": "hide" } );
+ $foo.animate( { "width": "show" } );
this.clock.tick( 1 );
@@ -681,119 +680,121 @@ QUnit.test("stop() - several in queue", function( assert ) {
$foo.stop( true );
assert.equal( $foo.queue().length, 0, "0 in the queue" );
-});
+} );
-QUnit.test("stop(clearQueue)", function( assert ) {
- assert.expect(4);
+QUnit.test( "stop(clearQueue)", function( assert ) {
+ assert.expect( 4 );
- var $foo = jQuery("#foo"),
+ var $foo = jQuery( "#foo" ),
w = 0,
nw;
- $foo.hide().css( "width", 200 ).css("width");
+ $foo.hide().css( "width", 200 ).css( "width" );
- $foo.animate({ "width": "show" }, 1000);
- $foo.animate({ "width": "hide" }, 1000);
- $foo.animate({ "width": "show" }, 1000);
+ $foo.animate( { "width": "show" }, 1000 );
+ $foo.animate( { "width": "hide" }, 1000 );
+ $foo.animate( { "width": "show" }, 1000 );
this.clock.tick( 100 );
- nw = $foo.css("width");
- assert.ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px");
- $foo.stop(true);
+ nw = $foo.css( "width" );
+ assert.ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px" );
+ $foo.stop( true );
- nw = $foo.css("width");
- assert.ok( parseFloat( nw ) !== w, "Stop didn't reset the animation " + nw + " " + w + "px");
+ nw = $foo.css( "width" );
+ assert.ok( parseFloat( nw ) !== w, "Stop didn't reset the animation " + nw + " " + w + "px" );
assert.equal( $foo.queue().length, 0, "The animation queue was cleared" );
this.clock.tick( 100 );
- assert.equal( nw, $foo.css("width"), "The animation didn't continue" );
-});
+ assert.equal( nw, $foo.css( "width" ), "The animation didn't continue" );
+} );
-QUnit.test("stop(clearQueue, gotoEnd)", function( assert ) {
- assert.expect(1);
+QUnit.test( "stop(clearQueue, gotoEnd)", function( assert ) {
+ assert.expect( 1 );
- var $foo = jQuery("#foo"),
+ var $foo = jQuery( "#foo" ),
w = 0,
nw;
- $foo.hide().css( "width", 200 ).css("width");
+ $foo.hide().css( "width", 200 ).css( "width" );
- $foo.animate({ width: "show" }, 1000);
- $foo.animate({ width: "hide" }, 1000);
- $foo.animate({ width: "show" }, 1000);
- $foo.animate({ width: "hide" }, 1000);
+ $foo.animate( { width: "show" }, 1000 );
+ $foo.animate( { width: "hide" }, 1000 );
+ $foo.animate( { width: "show" }, 1000 );
+ $foo.animate( { width: "hide" }, 1000 );
this.clock.tick( 100 );
- nw = $foo.css("width");
- assert.ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px");
- $foo.stop(false, true);
+ nw = $foo.css( "width" );
+ assert.ok( parseFloat( nw ) !== w, "An animation occurred " + nw + " " + w + "px" );
+ $foo.stop( false, true );
+
+ nw = $foo.css( "width" );
- nw = $foo.css("width");
// Disabled, being flaky
//equal( nw, 1, "Stop() reset the animation" );
this.clock.tick( 100 );
+
// Disabled, being flaky
//equal( $foo.queue().length, 2, "The next animation continued" );
- $foo.stop(true);
-});
+ $foo.stop( true );
+} );
QUnit.test( "stop( queue, ..., ... ) - Stop single queues", function( assert ) {
assert.expect( 3 );
var saved,
- foo = jQuery("#foo").css({ width: 200, height: 200 });
+ foo = jQuery( "#foo" ).css( { width: 200, height: 200 } );
- foo.animate({
+ foo.animate( {
width: 400
- },{
+ }, {
duration: 500,
complete: function() {
- assert.equal( parseFloat( foo.css("width") ), 400, "Animation completed for standard queue" );
- assert.equal( parseFloat( foo.css("height") ), saved, "Height was not changed after the second stop");
+ assert.equal( parseFloat( foo.css( "width" ) ), 400, "Animation completed for standard queue" );
+ assert.equal( parseFloat( foo.css( "height" ) ), saved, "Height was not changed after the second stop" );
}
- });
+ } );
- foo.animate({
+ foo.animate( {
height: 400
- },{
+ }, {
duration: 1000,
queue: "height"
- }).dequeue("height").stop( "height", false, true );
+ } ).dequeue( "height" ).stop( "height", false, true );
- assert.equal( parseFloat( foo.css("height") ), 400, "Height was stopped with gotoEnd" );
+ assert.equal( parseFloat( foo.css( "height" ) ), 400, "Height was stopped with gotoEnd" );
- foo.animate({
+ foo.animate( {
height: 200
- },{
+ }, {
duration: 1000,
queue: "height"
- }).dequeue( "height" ).stop( "height", false, false );
- saved = parseFloat( foo.css("height") );
+ } ).dequeue( "height" ).stop( "height", false, false );
+ saved = parseFloat( foo.css( "height" ) );
this.clock.tick( 500 );
-});
+} );
-QUnit.test("toggle()", function( assert ) {
- assert.expect(6);
- var x = jQuery("#foo");
- assert.ok( x.is(":visible"), "is visible" );
+QUnit.test( "toggle()", function( assert ) {
+ assert.expect( 6 );
+ var x = jQuery( "#foo" );
+ assert.ok( x.is( ":visible" ), "is visible" );
x.toggle();
- assert.ok( x.is(":hidden"), "is hidden" );
+ assert.ok( x.is( ":hidden" ), "is hidden" );
x.toggle();
- assert.ok( x.is(":visible"), "is visible again" );
+ assert.ok( x.is( ":visible" ), "is visible again" );
- x.toggle(true);
- assert.ok( x.is(":visible"), "is visible" );
- x.toggle(false);
- assert.ok( x.is(":hidden"), "is hidden" );
- x.toggle(true);
- assert.ok( x.is(":visible"), "is visible again" );
-});
+ x.toggle( true );
+ assert.ok( x.is( ":visible" ), "is visible" );
+ x.toggle( false );
+ assert.ok( x.is( ":hidden" ), "is hidden" );
+ x.toggle( true );
+ assert.ok( x.is( ":visible" ), "is visible again" );
+} );
QUnit.test( "jQuery.fx.prototype.cur() - <1.8 Back Compat", function( assert ) {
assert.expect( 7 );
- var div = jQuery( "
" ).appendTo( "#qunit-fixture" ).css({
+ var div = jQuery( "
" ).appendTo( "#qunit-fixture" ).css( {
color: "#ABC",
border: "5px solid black",
left: "auto",
marginBottom: "-11000px"
- })[0];
+ } )[ 0 ];
assert.equal(
( new jQuery.fx( div, {}, "color" ) ).cur(),
@@ -839,31 +840,31 @@ QUnit.test( "jQuery.fx.prototype.cur() - <1.8 Back Compat", function( assert ) {
);
jQuery( div ).remove();
-});
+} );
-QUnit.test("Overflow and Display", function( assert ) {
- assert.expect(4);
+QUnit.test( "Overflow and Display", function( assert ) {
+ assert.expect( 4 );
var
- testClass = jQuery.makeTest("Overflow and Display")
- .addClass("overflow inline"),
- testStyle = jQuery.makeTest("Overflow and Display (inline style)")
- .css({ overflow: "visible", display: "inline" }),
+ testClass = jQuery.makeTest( "Overflow and Display" )
+ .addClass( "overflow inline" ),
+ testStyle = jQuery.makeTest( "Overflow and Display (inline style)" )
+ .css( { overflow: "visible", display: "inline" } ),
done = function() {
assert.equal( jQuery.css( this, "overflow" ), "visible", "Overflow should be 'visible'" );
assert.equal( jQuery.css( this, "display" ), "inline", "Display should be 'inline'" );
};
testClass.add( testStyle )
- .addClass("widewidth")
- .text("Some sample text.")
- .before("text before")
- .after("text after")
- .animate({ opacity: 0.5 }, "slow", done );
+ .addClass( "widewidth" )
+ .text( "Some sample text." )
+ .before( "text before" )
+ .after( "text after" )
+ .animate( { opacity: 0.5 }, "slow", done );
this.clock.tick( 600 );
-});
+} );
-jQuery.each({
+jQuery.each( {
"CSS Auto": function( elem, prop ) {
jQuery( elem ).addClass( "auto" + prop )
.text( "This is a long string of text." );
@@ -899,7 +900,7 @@ jQuery.each({
return 0;
}
}, function( fn, f ) {
- jQuery.each({
+ jQuery.each( {
"show": function( elem, prop ) {
jQuery( elem ).hide().addClass( "wide" + prop );
return "show";
@@ -920,7 +921,7 @@ jQuery.each({
return 0;
}
}, function( tn, t ) {
- QUnit.test(fn + " to " + tn, function( assert ) {
+ QUnit.test( fn + " to " + tn, function( assert ) {
var num, anim,
elem = jQuery.makeTest( fn + " to " + tn ),
t_w = t( elem, "width" ),
@@ -935,6 +936,7 @@ jQuery.each({
}
num = 0;
+
// TODO: uncrowd this
if ( t_h === "show" ) { num++; }
if ( t_w === "show" ) { num++; }
@@ -950,9 +952,9 @@ jQuery.each({
anim = { width: t_w, height: t_h, opacity: t_o };
- elem.animate(anim, 50);
+ elem.animate( anim, 50 );
- jQuery.when( elem ).done(function( $elem ) {
+ jQuery.when( elem ).done( function( $elem ) {
var cur_o, cur_w, cur_h, old_h,
elem = $elem[ 0 ];
@@ -969,9 +971,9 @@ jQuery.each({
assert.ok( f_h === "" ? elem.style.height === f_h : elem.style.height.indexOf( f_h ) === 0, "Height must be reset to " + f_h + ": " + elem.style.height );
}
- cur_o = jQuery.style(elem, "opacity");
+ cur_o = jQuery.style( elem, "opacity" );
- if ( f_o !== jQuery.css(elem, "opacity") ) {
+ if ( f_o !== jQuery.css( elem, "opacity" ) ) {
f_o = f( elem, "opacity" );
}
@@ -986,13 +988,13 @@ jQuery.each({
if ( t_o.constructor === Number ) {
assert.equal( cur_o, t_o, "Final opacity should be " + t_o + ": " + cur_o );
- assert.ok( jQuery.css(elem, "opacity") !== "" || cur_o === t_o, "Opacity should be explicitly set to " + t_o + ", is instead: " + cur_o );
+ assert.ok( jQuery.css( elem, "opacity" ) !== "" || cur_o === t_o, "Opacity should be explicitly set to " + t_o + ", is instead: " + cur_o );
}
if ( t_w.constructor === Number ) {
assert.equal( elem.style.width, t_w + "px", "Final width should be " + t_w + ": " + elem.style.width );
- cur_w = jQuery.css( elem,"width" );
+ cur_w = jQuery.css( elem, "width" );
assert.ok( elem.style.width !== "" || cur_w === t_w, "Width should be explicitly set to " + t_w + ", is instead: " + cur_w );
}
@@ -1000,14 +1002,14 @@ jQuery.each({
if ( t_h.constructor === Number ) {
assert.equal( elem.style.height, t_h + "px", "Final height should be " + t_h + ": " + elem.style.height );
- cur_h = jQuery.css( elem,"height" );
+ cur_h = jQuery.css( elem, "height" );
assert.ok( elem.style.height !== "" || cur_h === t_h, "Height should be explicitly set to " + t_h + ", is instead: " + cur_h );
}
if ( t_h === "show" ) {
old_h = jQuery.css( elem, "height" );
- jQuery( elem ).append("
Some more text
and some more...");
+ jQuery( elem ).append( "
Some more text
and some more..." );
if ( /Auto/.test( fn ) ) {
assert.notEqual( jQuery.css( elem, "height" ), old_h, "Make sure height is auto." );
@@ -1019,18 +1021,18 @@ jQuery.each({
// manually remove generated element
jQuery( elem ).remove();
- });
+ } );
this.clock.tick( 50 );
- });
- });
-});
+ } );
+ } );
+} );
-QUnit.test("Effects chaining", function( assert ) {
+QUnit.test( "Effects chaining", function( assert ) {
var remaining = 16,
props = [ "opacity", "height", "width", "display", "overflow" ],
setup = function( name, selector ) {
var $el = jQuery( selector );
- return $el.data( getProps( $el[0] ) ).data( "name", name );
+ return $el.data( getProps( $el[ 0 ] ) ).data( "name", name );
},
check = function() {
var data = jQuery.data( this ),
@@ -1045,40 +1047,40 @@ QUnit.test("Effects chaining", function( assert ) {
var obj = {};
jQuery.each( props, function( i, prop ) {
obj[ prop ] = prop === "overflow" && el.style[ prop ] || jQuery.css( el, prop );
- });
+ } );
return obj;
};
assert.expect( remaining );
- setup( ".fadeOut().fadeIn()", "#fadein div" ).fadeOut("fast").fadeIn( "fast", check );
- setup( ".fadeIn().fadeOut()", "#fadeout div" ).fadeIn("fast").fadeOut( "fast", check );
- setup( ".hide().show()", "#show div" ).hide("fast").show( "fast", check );
- setup( ".show().hide()", "#hide div" ).show("fast").hide( "fast", check );
- setup( ".show().hide(easing)", "#easehide div" ).show("fast").hide( "fast", "linear", check );
- setup( ".toggle().toggle() - in", "#togglein div" ).toggle("fast").toggle( "fast", check );
- setup( ".toggle().toggle() - out", "#toggleout div" ).toggle("fast").toggle( "fast", check );
- setup( ".toggle().toggle(easing) - out", "#easetoggleout div" ).toggle("fast").toggle( "fast", "linear", check );
- setup( ".slideDown().slideUp()", "#slidedown div" ).slideDown("fast").slideUp( "fast", check );
- setup( ".slideUp().slideDown()", "#slideup div" ).slideUp("fast").slideDown( "fast", check );
- setup( ".slideUp().slideDown(easing)", "#easeslideup div" ).slideUp("fast").slideDown( "fast", "linear", check );
- setup( ".slideToggle().slideToggle() - in", "#slidetogglein div" ).slideToggle("fast").slideToggle( "fast", check );
- setup( ".slideToggle().slideToggle() - out", "#slidetoggleout div" ).slideToggle("fast").slideToggle( "fast", check );
- setup( ".fadeToggle().fadeToggle() - in", "#fadetogglein div" ).fadeToggle("fast").fadeToggle( "fast", check );
- setup( ".fadeToggle().fadeToggle() - out", "#fadetoggleout div" ).fadeToggle("fast").fadeToggle( "fast", check );
+ setup( ".fadeOut().fadeIn()", "#fadein div" ).fadeOut( "fast" ).fadeIn( "fast", check );
+ setup( ".fadeIn().fadeOut()", "#fadeout div" ).fadeIn( "fast" ).fadeOut( "fast", check );
+ setup( ".hide().show()", "#show div" ).hide( "fast" ).show( "fast", check );
+ setup( ".show().hide()", "#hide div" ).show( "fast" ).hide( "fast", check );
+ setup( ".show().hide(easing)", "#easehide div" ).show( "fast" ).hide( "fast", "linear", check );
+ setup( ".toggle().toggle() - in", "#togglein div" ).toggle( "fast" ).toggle( "fast", check );
+ setup( ".toggle().toggle() - out", "#toggleout div" ).toggle( "fast" ).toggle( "fast", check );
+ setup( ".toggle().toggle(easing) - out", "#easetoggleout div" ).toggle( "fast" ).toggle( "fast", "linear", check );
+ setup( ".slideDown().slideUp()", "#slidedown div" ).slideDown( "fast" ).slideUp( "fast", check );
+ setup( ".slideUp().slideDown()", "#slideup div" ).slideUp( "fast" ).slideDown( "fast", check );
+ setup( ".slideUp().slideDown(easing)", "#easeslideup div" ).slideUp( "fast" ).slideDown( "fast", "linear", check );
+ setup( ".slideToggle().slideToggle() - in", "#slidetogglein div" ).slideToggle( "fast" ).slideToggle( "fast", check );
+ setup( ".slideToggle().slideToggle() - out", "#slidetoggleout div" ).slideToggle( "fast" ).slideToggle( "fast", check );
+ setup( ".fadeToggle().fadeToggle() - in", "#fadetogglein div" ).fadeToggle( "fast" ).fadeToggle( "fast", check );
+ setup( ".fadeToggle().fadeToggle() - out", "#fadetoggleout div" ).fadeToggle( "fast" ).fadeToggle( "fast", check );
setup( ".fadeTo(0.5).fadeTo(1.0, easing)", "#fadeto div" ).fadeTo( "fast", 0.5 ).fadeTo( "fast", 1.0, "linear", check );
this.clock.tick( 400 );
-});
+} );
-jQuery.makeTest = function( text ){
- var elem = jQuery("
")
+jQuery.makeTest = function( text ) {
+ var elem = jQuery( "
" )
.attr( "id", "test" + jQuery.makeTest.id++ )
- .addClass("box");
+ .addClass( "box" );
- jQuery("
")
+ jQuery( "
" )
.text( text )
- .appendTo("#fx-tests")
+ .appendTo( "#fx-tests" )
.after( elem );
return elem;
@@ -1086,18 +1088,18 @@ jQuery.makeTest = function( text ){
jQuery.makeTest.id = 1;
-QUnit.test("jQuery.show('fast') doesn't clear radio buttons (bug #1095)", function( assert ) {
- assert.expect(4);
+QUnit.test( "jQuery.show('fast') doesn't clear radio buttons (bug #1095)", function( assert ) {
+ assert.expect( 4 );
- var $checkedtest = jQuery("#checkedtest");
- $checkedtest.hide().show("fast", function() {
- assert.ok( jQuery("input[type='radio']", $checkedtest).first().attr("checked"), "Check first radio still checked." );
- assert.ok( !jQuery("input[type='radio']", $checkedtest).last().attr("checked"), "Check last radio still NOT checked." );
- assert.ok( jQuery("input[type='checkbox']", $checkedtest).first().attr("checked"), "Check first checkbox still checked." );
- assert.ok( !jQuery("input[type='checkbox']", $checkedtest).last().attr("checked"), "Check last checkbox still NOT checked." );
- });
+ var $checkedtest = jQuery( "#checkedtest" );
+ $checkedtest.hide().show( "fast", function() {
+ assert.ok( jQuery( "input[type='radio']", $checkedtest ).first().attr( "checked" ), "Check first radio still checked." );
+ assert.ok( !jQuery( "input[type='radio']", $checkedtest ).last().attr( "checked" ), "Check last radio still NOT checked." );
+ assert.ok( jQuery( "input[type='checkbox']", $checkedtest ).first().attr( "checked" ), "Check first checkbox still checked." );
+ assert.ok( !jQuery( "input[type='checkbox']", $checkedtest ).last().attr( "checked" ), "Check last checkbox still NOT checked." );
+ } );
this.clock.tick( 200 );
-});
+} );
QUnit.test( "interrupt toggle", function( assert ) {
assert.expect( 24 );
@@ -1106,13 +1108,14 @@ QUnit.test( "interrupt toggle", function( assert ) {
longDuration = 2000,
shortDuration = 500,
remaining = 0,
- $elems = jQuery(".chain-test"),
+ $elems = jQuery( ".chain-test" ),
clock = this.clock,
finish = function() {
};
jQuery.each( { slideToggle: "height", fadeToggle: "opacity", toggle: "width" }, function( method, prop ) {
- var $methodElems = $elems.filter( "[id^='" + method.toLowerCase() + "']" ).each(function() {
+ var $methodElems = $elems.filter( "[id^='" + method.toLowerCase() + "']" ).each( function() {
+
// Don't end test until we're done with this element
remaining++;
@@ -1121,28 +1124,28 @@ QUnit.test( "interrupt toggle", function( assert ) {
// Expect olddisplay data from our .hide() call below
QUnit.expectJqData( env, this, "olddisplay" );
- });
+ } );
// Interrupt a hiding toggle
$methodElems[ method ]( longDuration );
- setTimeout(function() {
- $methodElems.stop().each(function() {
+ setTimeout( function() {
+ $methodElems.stop().each( function() {
assert.notEqual( jQuery( this ).css( prop ), jQuery.data( this, "startVal" ), ".stop() before completion of hiding ." + method + "() - #" + this.id );
- });
+ } );
// Restore
$methodElems[ method ]( shortDuration, function() {
var id = this.id,
$elem = jQuery( this ),
- startVal = $elem.data("startVal");
+ startVal = $elem.data( "startVal" );
- $elem.removeData("startVal");
+ $elem.removeData( "startVal" );
assert.equal( $elem.css( prop ), startVal, "original value restored by ." + method + "() - #" + id );
// Interrupt a showing toggle
$elem.hide()[ method ]( longDuration );
- setTimeout(function() {
+ setTimeout( function() {
$elem.stop();
assert.notEqual( $elem.css( prop ), startVal, ".stop() before completion of showing ." + method + "() - #" + id );
@@ -1150,15 +1153,15 @@ QUnit.test( "interrupt toggle", function( assert ) {
$elem[ method ]( shortDuration, function() {
assert.equal( $elem.css( prop ), startVal, "original value restored by ." + method + "() - #" + id );
finish();
- });
+ } );
}, shortDuration );
- });
+ } );
}, shortDuration );
- });
+ } );
clock.tick( longDuration );
// FIXME untangle the set timeouts
-});
+} );
QUnit.test( "animate with per-property easing", function( assert ) {
@@ -1195,34 +1198,34 @@ QUnit.test( "animate with per-property easing", function( assert ) {
assert.ok( defaultTestCalled, "Easing function (_default) called" );
assert.equal( props.a[ 1 ], "_test1", "animate does not change original props (per-property easing would be lost)" );
assert.equal( props.b[ 1 ], "_test2", "animate does not change original props (per-property easing would be lost)" );
- });
+ } );
this.clock.tick( 400 );
-});
+} );
-QUnit.test("animate with CSS shorthand properties", function( assert ){
- assert.expect(11);
+QUnit.test( "animate with CSS shorthand properties", function( assert ) {
+ assert.expect( 11 );
var easeAnimation_count = 0,
easeProperty_count = 0,
propsBasic = { "padding": "10 20 30" },
propsSpecial = { "padding": [ "1 2 3", "propertyScope" ] };
- jQuery.easing.animationScope = function(p) {
+ jQuery.easing.animationScope = function( p ) {
if ( p >= 1 ) {
easeAnimation_count++;
}
return p;
};
- jQuery.easing.propertyScope = function(p) {
+ jQuery.easing.propertyScope = function( p ) {
if ( p >= 1 ) {
easeProperty_count++;
}
return p;
};
- jQuery("#foo")
+ jQuery( "#foo" )
.animate( propsBasic, 200, "animationScope", function() {
assert.equal( this.style.paddingTop, "10px", "padding-top was animated" );
assert.equal( this.style.paddingLeft, "20px", "padding-left was animated" );
@@ -1230,7 +1233,7 @@ QUnit.test("animate with CSS shorthand properties", function( assert ){
assert.equal( this.style.paddingBottom, "30px", "padding-bottom was animated" );
assert.equal( easeAnimation_count, 4, "per-animation default easing called for each property" );
easeAnimation_count = 0;
- })
+ } )
.animate( propsSpecial, 200, "animationScope", function() {
assert.equal( this.style.paddingTop, "1px", "padding-top was animated again" );
assert.equal( this.style.paddingLeft, "2px", "padding-left was animated again" );
@@ -1239,37 +1242,37 @@ QUnit.test("animate with CSS shorthand properties", function( assert ){
assert.equal( easeAnimation_count, 0, "per-animation default easing not called" );
assert.equal( easeProperty_count, 4, "special easing called for each property" );
- jQuery(this).css("padding", "0");
+ jQuery( this ).css( "padding", "0" );
delete jQuery.easing.animationScope;
delete jQuery.easing.propertyScope;
- });
+ } );
this.clock.tick( 400 );
-});
+} );
-QUnit.test("hide hidden elements, with animation (bug #7141)", function( assert ) {
- assert.expect(3);
+QUnit.test( "hide hidden elements, with animation (bug #7141)", function( assert ) {
+ assert.expect( 3 );
- var div = jQuery("
").appendTo("#qunit-fixture");
- assert.equal( div.css("display"), "none", "Element is hidden by default" );
- div.hide(1, function () {
- assert.ok( !jQuery._data(div, "olddisplay"), "olddisplay is undefined after hiding an already-hidden element" );
- div.show(1, function () {
- assert.equal( div.css("display"), "block", "Show a double-hidden element" );
- });
- });
+ var div = jQuery( "
" ).appendTo( "#qunit-fixture" );
+ assert.equal( div.css( "display" ), "none", "Element is hidden by default" );
+ div.hide( 1, function() {
+ assert.ok( !jQuery._data( div, "olddisplay" ), "olddisplay is undefined after hiding an already-hidden element" );
+ div.show( 1, function() {
+ assert.equal( div.css( "display" ), "block", "Show a double-hidden element" );
+ } );
+ } );
this.clock.tick( 10 );
-});
+} );
-QUnit.test("animate unit-less properties (#4966)", function( assert ) {
+QUnit.test( "animate unit-less properties (#4966)", function( assert ) {
assert.expect( 2 );
var div = jQuery( "
" ).appendTo( "#qunit-fixture" );
assert.equal( div.css( "z-index" ), "0", "z-index is 0" );
- div.animate({ zIndex: 2 }, function() {
+ div.animate( { zIndex: 2 }, function() {
assert.equal( div.css( "z-index" ), "2", "z-index is 2" );
- });
+ } );
this.clock.tick( 400 );
-});
+} );
QUnit.test( "animate properties missing px w/ opacity as last (#9074)", function( assert ) {
assert.expect( 6 );
@@ -1282,11 +1285,11 @@ QUnit.test( "animate properties missing px w/ opacity as last (#9074)", function
}
assert.equal( cssInt( "marginLeft" ), 0, "Margin left is 0" );
assert.equal( cssInt( "left" ), 0, "Left is 0" );
- div.animate({
+ div.animate( {
left: 200,
marginLeft: 200,
opacity: 0
- }, 2000);
+ }, 2000 );
this.clock.tick( 500 );
@@ -1297,25 +1300,26 @@ QUnit.test( "animate properties missing px w/ opacity as last (#9074)", function
assert.notEqual( l, 0, "Left is not 0 after partial animate" );
assert.notEqual( l, 200, "Left is not 200 after partial animate" );
div.stop().remove();
-});
+} );
-QUnit.test("callbacks should fire in correct order (#9100)", function( assert ) {
+QUnit.test( "callbacks should fire in correct order (#9100)", function( assert ) {
assert.expect( 1 );
var a = 1,
cb = 0;
- jQuery("
").appendTo("#qunit-fixture")
+ jQuery( "
" ).appendTo( "#qunit-fixture" )
+
// The test will always pass if no properties are animated or if the duration is 0
- .animate({fontSize: 12}, 13, function() {
- a *= jQuery(this).data("operation") === "*2" ? 2 : a;
+ .animate( { fontSize: 12 }, 13, function() {
+ a *= jQuery( this ).data( "operation" ) === "*2" ? 2 : a;
cb++;
if ( cb === 2 ) {
- assert.equal( a, 4, "test value has been *2 and _then_ ^2");
+ assert.equal( a, 4, "test value has been *2 and _then_ ^2" );
}
- });
+ } );
this.clock.tick( 20 );
-});
+} );
QUnit.test( "callbacks that throw exceptions will be removed (#5684)", function( assert ) {
assert.expect( 2 );
@@ -1325,9 +1329,9 @@ QUnit.test( "callbacks that throw exceptions will be removed (#5684)", function(
function TestException() {
}
- foo.animate({ height: 1 }, 1, function() {
+ foo.animate( { height: 1 }, 1, function() {
throw new TestException();
- });
+ } );
// this test thoroughly abuses undocumented methods - please feel free to update
// with any changes internally to these functions.
@@ -1343,39 +1347,40 @@ QUnit.test( "callbacks that throw exceptions will be removed (#5684)", function(
assert.ok( true, "Test completed without throwing a second exception" );
-});
+} );
-QUnit.test("animate will scale margin properties individually", function( assert ) {
+QUnit.test( "animate will scale margin properties individually", function( assert ) {
assert.expect( 2 );
- var foo = jQuery( "#foo" ).css({
+ var foo = jQuery( "#foo" ).css( {
"margin": 0,
"marginLeft": 100
- });
+ } );
assert.ok( foo.css( "marginLeft" ) !== foo.css( "marginRight" ), "Sanity Check" );
- foo.animate({
+ foo.animate( {
"margin": 200
- }).stop();
+ } ).stop();
- assert.ok( foo.css( "marginLeft") !== foo.css( "marginRight" ), "The margin properties are different");
+ assert.ok( foo.css( "marginLeft" ) !== foo.css( "marginRight" ), "The margin properties are different" );
// clean up for next test
- foo.css({
+ foo.css( {
"marginLeft": "",
"marginRight": "",
"marginTop": "",
"marginBottom": ""
- });
-});
+ } );
+} );
-QUnit.test("Do not append px to 'fill-opacity' #9548", function( assert ) {
+QUnit.test( "Do not append px to 'fill-opacity' #9548", function( assert ) {
assert.expect( 1 );
- var $div = jQuery("
").appendTo("#qunit-fixture");
+ var $div = jQuery( "
" ).appendTo( "#qunit-fixture" );
+
+ $div.css( "fill-opacity", 0 ).animate( { "fill-opacity": 1.0 }, 0, function() {
- $div.css("fill-opacity", 0).animate({ "fill-opacity": 1.0 }, 0, function () {
// Support: Android 2.3 (no support for fill-opacity)
if ( jQuery( this ).css( "fill-opacity" ) ) {
assert.equal( jQuery( this ).css( "fill-opacity" ), 1, "Do not append px to 'fill-opacity'" );
@@ -1383,10 +1388,10 @@ QUnit.test("Do not append px to 'fill-opacity' #9548", function( assert ) {
assert.ok( true, "No support for fill-opacity CSS property" );
}
$div.remove();
- });
-});
+ } );
+} );
-QUnit.test("line-height animates correctly (#13855)", function( assert ) {
+QUnit.test( "line-height animates correctly (#13855)", function( assert ) {
assert.expect( 12 );
var t0,
@@ -1398,22 +1403,22 @@ QUnit.test("line-height animates correctly (#13855)", function( assert ) {
"
px
" +
"
percent
" +
"
em
"
- ).appendTo("#qunit-fixture"),
+ ).appendTo( "#qunit-fixture" ),
initialHeight = jQuery.map( animated, function( el ) {
return jQuery( el ).height();
- }),
+ } ),
tolerance = 1.5;
// Delay start to improve test stability
- setTimeout(function() {
+ setTimeout( function() {
- t0 = +(new Date());
+ t0 = +( new Date() );
animated.animate( { "line-height": "hide" }, longDuration, "linear" );
- setTimeout(function() {
- var progress = ( (new Date()) - t0 ) / longDuration;
+ setTimeout( function() {
+ var progress = ( ( new Date() ) - t0 ) / longDuration;
- animated.each(function( i ) {
+ animated.each( function( i ) {
var label = jQuery.text( this ),
initial = initialHeight[ i ],
height = jQuery( this ).height(),
@@ -1422,32 +1427,32 @@ QUnit.test("line-height animates correctly (#13855)", function( assert ) {
height + " < " + initial + " @ " + ( progress * 100 ) + "%" );
assert.ok( height > lower, "hide " + label + ": lower bound; " +
height + " > " + lower + " @ " + ( progress * 100 ) + "%" );
- });
+ } );
- t0 = +(new Date());
+ t0 = +( new Date() );
animated.stop( true, true ).hide()
.animate( { "line-height": "show" }, longDuration, "linear" );
- setTimeout(function() {
- var progress = ( (new Date()) - t0 ) / longDuration;
+ setTimeout( function() {
+ var progress = ( ( new Date() ) - t0 ) / longDuration;
- animated.each(function( i ) {
+ animated.each( function( i ) {
var label = jQuery.text( this ),
initial = initialHeight[ i ],
height = jQuery( this ).height(),
upper = initial * progress * tolerance;
assert.ok( height < upper, "show " + label + ": upper bound; " +
height + " < " + upper + " @ " + ( progress * 100 ) + "%" );
- });
+ } );
animated.stop( true, true );
}, shortDuration );
-clock.tick(shortDuration);
+clock.tick( shortDuration );
}, shortDuration );
-clock.tick(shortDuration);
+clock.tick( shortDuration );
}, 50 );
clock.tick( 50 );
-});
+} );
// Start 1.8 Animation tests
QUnit.test( "jQuery.Animation( object, props, opts )", function( assert ) {
@@ -1465,23 +1470,23 @@ QUnit.test( "jQuery.Animation( object, props, opts )", function( assert ) {
"width": 200
};
- animation = jQuery.Animation( testObject, testDest, { "duration": 1 });
- animation.done(function() {
+ animation = jQuery.Animation( testObject, testDest, { "duration": 1 } );
+ animation.done( function() {
for ( var prop in testDest ) {
assert.equal( testObject[ prop ], testDest[ prop ], "Animated: " + prop );
}
- animation.done(function() {
+ animation.done( function() {
assert.deepEqual( testObject, testDest, "No unexpected properties" );
- });
- });
+ } );
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "Animate Option: step: function( percent, tween )", function( assert ) {
assert.expect( 1 );
var counter = {};
- jQuery( "#foo" ).animate({
+ jQuery( "#foo" ).animate( {
prop1: 1,
prop2: 2,
prop3: 3
@@ -1489,37 +1494,38 @@ QUnit.test( "Animate Option: step: function( percent, tween )", function( assert
duration: 1,
step: function( value, tween ) {
var calls = counter[ tween.prop ] = counter[ tween.prop ] || [];
+
// in case this is called multiple times for either, lets store it in
// 0 or 1 in the array
calls[ value === 0 ? 0 : 1 ] = value;
}
- }).queue( function( next ) {
+ } ).queue( function( next ) {
assert.deepEqual( counter, {
- prop1: [0, 1],
- prop2: [0, 2],
- prop3: [0, 3]
- }, "Step function was called once at 0% and once at 100% for each property");
+ prop1: [ 0, 1 ],
+ prop2: [ 0, 2 ],
+ prop3: [ 0, 3 ]
+ }, "Step function was called once at 0% and once at 100% for each property" );
next();
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "Animate callbacks have correct context", function( assert ) {
assert.expect( 2 );
var foo = jQuery( "#foo" );
- foo.animate({
+ foo.animate( {
height: 10
}, 10, function() {
assert.equal( foo[ 0 ], this, "Complete callback after stop(true) `this` is element" );
- }).stop( true, true );
- foo.animate({
+ } ).stop( true, true );
+ foo.animate( {
height: 100
}, 10, function() {
assert.equal( foo[ 0 ], this, "Complete callback `this` is element" );
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "User supplied callback called after show when fx off (#8892)", function( assert ) {
assert.expect( 2 );
@@ -1532,10 +1538,10 @@ QUnit.test( "User supplied callback called after show when fx off (#8892)", func
foo.fadeOut( 500, function() {
assert.ok( jQuery( this ).is( ":hidden" ), "Element is hidden in callback" );
jQuery.fx.off = false;
- });
- });
+ } );
+ } );
this.clock.tick( 1000 );
-});
+} );
QUnit.test( "animate should set display for disconnected nodes", function( assert ) {
assert.expect( 20 );
@@ -1548,18 +1554,18 @@ QUnit.test( "animate should set display for disconnected nodes", function( asser
fadeTo: [ "fast", 0.5 ],
slideDown: [ "fast" ],
show: [ 1 ],
- animate: [{ width: "show" }]
+ animate: [ { width: "show" } ]
},
- $divEmpty = jQuery("
"),
- $divTest = jQuery("
test
"),
- $divNone = jQuery("
"),
- $divInline = jQuery("
"),
- nullParentDisplay = $divEmpty.css("display"),
- underFragmentDisplay = $divTest.css("display"),
+ $divEmpty = jQuery( "
" ),
+ $divTest = jQuery( "
test
" ),
+ $divNone = jQuery( "
" ),
+ $divInline = jQuery( "
" ),
+ nullParentDisplay = $divEmpty.css( "display" ),
+ underFragmentDisplay = $divTest.css( "display" ),
clock = this.clock;
assert.strictEqual( $divEmpty[ 0 ].parentNode, null, "Setup: element with null parentNode" );
- assert.strictEqual( ($divTest[ 0 ].parentNode || {}).nodeType, 11, "Setup: element under fragment" );
+ assert.strictEqual( ( $divTest[ 0 ].parentNode || {} ).nodeType, 11, "Setup: element under fragment" );
assert.strictEqual( $divEmpty.show()[ 0 ].style.display, "",
"set display with show() for element with null parentNode" );
@@ -1573,54 +1579,54 @@ QUnit.test( "animate should set display for disconnected nodes", function( asser
QUnit.expectJqData( env, $divNone[ 0 ], "olddisplay" );
jQuery.each( methods, function( name, opt ) {
- jQuery.fn[ name ].apply( jQuery("
"), opt.concat( [ function() {
+ jQuery.fn[ name ].apply( jQuery( "
" ), opt.concat( [ function() {
assert.strictEqual( jQuery( this ).css( "display" ), nullParentDisplay,
"." + name + " block with null parentNode" );
} ] ) );
- jQuery.fn[ name ].apply( jQuery("
test
"), opt.concat( [ function() {
+ jQuery.fn[ name ].apply( jQuery( "
test
" ), opt.concat( [ function() {
assert.strictEqual( jQuery( this ).css( "display" ), underFragmentDisplay,
"." + name + " block under fragment" );
} ] ) );
- });
+ } );
clock.tick( 400 );
-});
+} );
-QUnit.test("Animation callback should not show animated element as :animated (#7157)", function( assert ) {
+QUnit.test( "Animation callback should not show animated element as :animated (#7157)", function( assert ) {
assert.expect( 1 );
var foo = jQuery( "#foo" );
- foo.animate({
+ foo.animate( {
opacity: 0
}, 100, function() {
- assert.ok( !foo.is(":animated"), "The element is not animated" );
- });
+ assert.ok( !foo.is( ":animated" ), "The element is not animated" );
+ } );
this.clock.tick( 100 );
-});
+} );
-QUnit.test("Initial step callback should show element as :animated (#14623)", function( assert ) {
+QUnit.test( "Initial step callback should show element as :animated (#14623)", function( assert ) {
assert.expect( 1 );
var foo = jQuery( "#foo" );
- foo.animate({
+ foo.animate( {
opacity: 0
}, {
duration: 100,
step: function() {
- assert.ok( foo.is(":animated"), "The element matches :animated inside step function" );
+ assert.ok( foo.is( ":animated" ), "The element matches :animated inside step function" );
}
- });
+ } );
this.clock.tick( 1 );
foo.stop();
-});
+} );
QUnit.test( "hide called on element within hidden parent should set display to none (#10045)", function( assert ) {
assert.expect( 3 );
- var hidden = jQuery(".hidden"),
- elems = jQuery("
hide
hide0
hide1
");
+ var hidden = jQuery( ".hidden" ),
+ elems = jQuery( "
hide
hide0
hide1
" );
hidden.append( elems );
@@ -1628,25 +1634,25 @@ QUnit.test( "hide called on element within hidden parent should set display to n
elems.eq( 0 ).hide(),
elems.eq( 1 ).hide( 0 ),
elems.eq( 2 ).hide( 1 )
- ).done(function() {
+ ).done( function() {
assert.strictEqual( elems.get( 0 ).style.display, "none", "hide() called on element within hidden parent should set display to none" );
assert.strictEqual( elems.get( 1 ).style.display, "none", "hide( 0 ) called on element within hidden parent should set display to none" );
assert.strictEqual( elems.get( 2 ).style.display, "none", "hide( 1 ) called on element within hidden parent should set display to none" );
elems.remove();
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "hide, fadeOut and slideUp called on element width height and width = 0 should set display to none", function( assert ) {
assert.expect( 5 );
- var foo = jQuery("#foo"),
+ var foo = jQuery( "#foo" ),
i = 0,
elems = jQuery();
for ( ; i < 5; i++ ) {
- elems = elems.add("
");
+ elems = elems.add( "
" );
}
foo.append( elems );
@@ -1657,7 +1663,7 @@ QUnit.test( "hide, fadeOut and slideUp called on element width height and width
elems.eq( 2 ).hide( 1 ),
elems.eq( 3 ).fadeOut(),
elems.eq( 4 ).slideUp()
- ).done(function() {
+ ).done( function() {
assert.strictEqual( elems.get( 0 ).style.display, "none", "hide() called on element width height and width = 0 should set display to none" );
assert.strictEqual( elems.get( 1 ).style.display, "none",
"hide( jQuery.noop ) called on element width height and width = 0 should set display to none" );
@@ -1665,24 +1671,24 @@ QUnit.test( "hide, fadeOut and slideUp called on element width height and width
assert.strictEqual( elems.get( 3 ).style.display, "none", "fadeOut() called on element width height and width = 0 should set display to none" );
assert.strictEqual( elems.get( 4 ).style.display, "none", "slideUp() called on element width height and width = 0 should set display to none" );
- });
+ } );
this.clock.tick( 400 );
-});
+} );
QUnit.test( "hide should not leave hidden inline elements visible (#14848)", function( assert ) {
assert.expect( 2 );
- var el = jQuery("#simon1");
+ var el = jQuery( "#simon1" );
el.hide( 1, function() {
assert.equal( el.css( "display" ), "none", "hidden" );
el.hide( 1, function() {
assert.equal( el.css( "display" ), "none", "still hidden" );
- });
- });
+ } );
+ } );
this.clock.tick( 100 );
-});
+} );
QUnit.test( "Handle queue:false promises", function( assert ) {
assert.expect( 10 );
@@ -1690,7 +1696,7 @@ QUnit.test( "Handle queue:false promises", function( assert ) {
var foo = jQuery( "#foo" ).clone().addBack(),
step = 1;
- foo.animate({
+ foo.animate( {
top: 1
}, {
duration: 10,
@@ -1698,7 +1704,7 @@ QUnit.test( "Handle queue:false promises", function( assert ) {
complete: function() {
assert.ok( step++ <= 2, "Step one or two" );
}
- }).animate({
+ } ).animate( {
bottom: 1
}, {
duration: 10,
@@ -1706,13 +1712,13 @@ QUnit.test( "Handle queue:false promises", function( assert ) {
assert.ok( step > 2 && step < 5, "Step three or four" );
step++;
}
- });
+ } );
this.clock.tick( 10 );
foo.promise().done( function() {
assert.equal( step++, 5, "steps 1-5: queue:false then queue:fx done" );
- foo.animate({
+ foo.animate( {
top: 10
}, {
duration: 10,
@@ -1720,7 +1726,7 @@ QUnit.test( "Handle queue:false promises", function( assert ) {
assert.ok( step > 5 && step < 8, "Step six or seven" );
step++;
}
- }).animate({
+ } ).animate( {
bottom: 10
}, {
duration: 10,
@@ -1729,20 +1735,20 @@ QUnit.test( "Handle queue:false promises", function( assert ) {
assert.ok( step > 7 && step < 10, "Step eight or nine" );
step++;
}
- }).promise().done( function() {
+ } ).promise().done( function() {
assert.equal( step++, 10, "steps 6-10: queue:fx then queue:false" );
- });
+ } );
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "multiple unqueued and promise", function( assert ) {
assert.expect( 4 );
var foo = jQuery( "#foo" ),
step = 1;
- foo.animate({
+ foo.animate( {
marginLeft: 300
}, {
duration: 500,
@@ -1750,7 +1756,7 @@ QUnit.test( "multiple unqueued and promise", function( assert ) {
complete: function() {
assert.strictEqual( step++, 2, "Step 2" );
}
- }).animate({
+ } ).animate( {
top: 100
}, {
duration: 1000,
@@ -1758,54 +1764,55 @@ QUnit.test( "multiple unqueued and promise", function( assert ) {
complete: function() {
assert.strictEqual( step++, 3, "Step 3" );
}
- }).animate({}, {
+ } ).animate( {}, {
duration: 2000,
queue: false,
complete: function() {
+
// no properties is a non-op and finishes immediately
assert.strictEqual( step++, 1, "Step 1" );
}
- }).promise().done( function() {
+ } ).promise().done( function() {
assert.strictEqual( step++, 4, "Step 4" );
- });
+ } );
this.clock.tick( 1000 );
-});
+} );
QUnit.test( "animate does not change start value for non-px animation (#7109)", function( assert ) {
assert.expect( 1 );
- var parent = jQuery( "
" ).css({ width: 284, height: 1 }).appendTo( "#qunit-fixture" ),
- child = parent.children().css({ fontSize: "98.6in", width: "0.01em", height: 1 }),
+ var parent = jQuery( "
" ).css( { width: 284, height: 1 } ).appendTo( "#qunit-fixture" ),
+ child = parent.children().css( { fontSize: "98.6in", width: "0.01em", height: 1 } ),
actual = parseFloat( child.css( "width" ) ),
computed = [];
- child.animate({ width: "0%" }, {
+ child.animate( { width: "0%" }, {
duration: 1,
step: function() {
computed.push( parseFloat( child.css( "width" ) ) );
}
- }).queue( function( next ) {
+ } ).queue( function( next ) {
var ratio = computed[ 0 ] / actual;
- assert.ok( ratio > 0.9 && ratio < 1.1 , "Starting width was close enough" );
+ assert.ok( ratio > 0.9 && ratio < 1.1, "Starting width was close enough" );
next();
parent.remove();
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "non-px animation handles non-numeric start (#11971)", function( assert ) {
assert.expect( 2 );
- var foo = jQuery("#foo"),
- initial = foo.css("backgroundPositionX");
+ var foo = jQuery( "#foo" ),
+ initial = foo.css( "backgroundPositionX" );
if ( !initial ) {
- assert.expect(1);
+ assert.expect( 1 );
assert.ok( true, "Style property not understood" );
return;
}
- foo.animate({ backgroundPositionX: "42%" }, {
+ foo.animate( { backgroundPositionX: "42%" }, {
duration: 1,
progress: function( anim, percent ) {
if ( percent ) {
@@ -1821,14 +1828,14 @@ QUnit.test( "non-px animation handles non-numeric start (#11971)", function( ass
done: function() {
assert.equal( jQuery.style( this, "backgroundPositionX" ), "42%", "End reached" );
}
- });
+ } );
this.clock.tick( 10 );
-});
+} );
-QUnit.test("Animation callbacks (#11797)", function( assert ) {
+QUnit.test( "Animation callbacks (#11797)", function( assert ) {
assert.expect( 15 );
- var targets = jQuery("#foo").children(),
+ var targets = jQuery( "#foo" ).children(),
done = false,
expectedProgress = 0;
@@ -1850,12 +1857,12 @@ QUnit.test("Animation callbacks (#11797)", function( assert ) {
assert.ok( true, "empty: always" );
done = true;
}
- });
+ } );
assert.ok( done, "empty: done immediately" );
done = false;
- targets.eq( 1 ).animate({
+ targets.eq( 1 ).animate( {
opacity: 0
}, {
duration: 1,
@@ -1875,11 +1882,11 @@ QUnit.test("Animation callbacks (#11797)", function( assert ) {
assert.ok( true, "stopped: always" );
done = true;
}
- }).stop();
+ } ).stop();
assert.ok( done, "stopped: stopped immediately" );
- targets.eq( 2 ).animate({
+ targets.eq( 2 ).animate( {
opacity: 0
}, {
duration: 1,
@@ -1887,11 +1894,13 @@ QUnit.test("Animation callbacks (#11797)", function( assert ) {
assert.ok( true, "async: start" );
},
progress: function( anim, percent ) {
+
// occasionally the progress handler is called twice in first frame.... *shrug*
if ( percent === 0 && expectedProgress === 1 ) {
return;
}
assert.equal( percent, expectedProgress, "async: progress " + expectedProgress );
+
// once at 0, once at 1
expectedProgress++;
},
@@ -1904,16 +1913,16 @@ QUnit.test("Animation callbacks (#11797)", function( assert ) {
always: function() {
assert.ok( true, "async: always" );
}
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "Animate properly sets overflow hidden when animating width/height (#12117)", function( assert ) {
assert.expect( 8 );
jQuery.each( [ "height", "width" ], function( _, prop ) {
jQuery.each( [ 100, 0 ], function( _, value ) {
- var div = jQuery("
").css( "overflow", "auto" ),
+ var div = jQuery( "
" ).css( "overflow", "auto" ),
props = {};
props[ prop ] = value;
div.animate( props, 1 );
@@ -1922,24 +1931,24 @@ QUnit.test( "Animate properly sets overflow hidden when animating width/height (
div.stop();
assert.equal( div.css( "overflow" ), "auto",
"overflow: auto restored after animating " + prop + " to " + value );
- });
- });
-});
+ } );
+ } );
+} );
QUnit.test( "Each tick of the timer loop uses a fresh time (#12837)", function( assert ) {
var lastVal,
- tmp = jQuery({
+ tmp = jQuery( {
test: 0
- });
+ } );
assert.expect( 3 );
- tmp.animate({
+ tmp.animate( {
test: 100
}, {
step: function( p, fx ) {
assert.ok( fx.now !== lastVal, "Current value is not the last value: " + lastVal + " - " + fx.now );
lastVal = fx.now;
}
- });
+ } );
this.clock.tick( 1 );
// now that we have a new time, run another tick
@@ -1949,7 +1958,7 @@ QUnit.test( "Each tick of the timer loop uses a fresh time (#12837)", function(
jQuery.fx.tick();
tmp.stop();
-});
+} );
QUnit.test( "Animations with 0 duration don't ease (#12273)", function( assert ) {
assert.expect( 1 );
@@ -1958,7 +1967,7 @@ QUnit.test( "Animations with 0 duration don't ease (#12273)", function( assert )
assert.ok( false, "Called easing" );
};
- jQuery( "#foo" ).animate({
+ jQuery( "#foo" ).animate( {
height: 100
}, {
duration: 0,
@@ -1966,12 +1975,13 @@ QUnit.test( "Animations with 0 duration don't ease (#12273)", function( assert )
complete: function() {
assert.equal( jQuery( this ).height(), 100, "Height is 100" );
}
- });
+ } );
delete jQuery.easing.test;
-});
+} );
+
+jQuery.map( [ "toggle", "slideToggle", "fadeToggle" ], function( method ) {
-jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
// this test would look a lot better if we were using something to override
// the default timers
var duration = 1500;
@@ -1979,7 +1989,7 @@ jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
function secondToggle() {
var stopped = parseFloat( element.css( check ) );
tested = false;
- element[ method ]({
+ element[ method ]( {
duration: duration,
step: function( p, fx ) {
if ( fx.pos > 0.1 && fx.prop === check && !tested ) {
@@ -1989,17 +1999,17 @@ jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
element.stop();
}
}
- });
+ } );
}
var tested,
original,
check = method === "slideToggle" ? "height" : "opacity",
- element = jQuery("#foo").height( 200 );
+ element = jQuery( "#foo" ).height( 200 );
assert.expect( 4 );
- element[ method ]({
+ element[ method ]( {
duration: duration,
easing: "linear",
step: function( p, fx ) {
@@ -2012,16 +2022,17 @@ jQuery.map([ "toggle", "slideToggle", "fadeToggle" ], function ( method ) {
}
},
always: secondToggle
- });
+ } );
+
//FIXME figure out why 470
this.clock.tick( 470 );
- });
-});
+ } );
+} );
QUnit.test( "jQuery.fx.start & jQuery.fx.stop hook points", function( assert ) {
var oldStart = jQuery.fx.start,
oldStop = jQuery.fx.stop,
- foo = jQuery({ foo: 0 });
+ foo = jQuery( { foo: 0 } );
assert.expect( 3 );
@@ -2033,17 +2044,19 @@ QUnit.test( "jQuery.fx.start & jQuery.fx.stop hook points", function( assert ) {
};
// calls start
- foo.animate({ foo: 1 }, { queue: false });
+ foo.animate( { foo: 1 }, { queue: false } );
+
// calls start
- foo.animate({ foo: 2 }, { queue: false });
+ foo.animate( { foo: 2 }, { queue: false } );
foo.stop();
+
// calls stop
jQuery.fx.tick();
// cleanup
jQuery.fx.start = oldStart;
jQuery.fx.stop = oldStop;
-});
+} );
QUnit.test( ".finish() completes all queued animations", function( assert ) {
var animations = {
@@ -2052,31 +2065,33 @@ QUnit.test( ".finish() completes all queued animations", function( assert ) {
height: 100,
width: 100
},
- div = jQuery("
");
+ div = jQuery( "
" );
assert.expect( 11 );
jQuery.each( animations, function( prop, value ) {
var anim = {};
anim[ prop ] = value;
+
// the delay shouldn't matter at all!
div.css( prop, 1 ).animate( anim, function() {
assert.ok( true, "Called animation callback for " + prop );
- }).delay( 100 );
- });
+ } ).delay( 100 );
+ } );
assert.equal( div.queue().length, 8, "8 animations in the queue" );
div.finish();
jQuery.each( animations, function( prop, value ) {
assert.equal( parseFloat( div.css( prop ) ), value, prop + " finished at correct value" );
- });
+ } );
assert.equal( div.queue().length, 0, "empty queue when done" );
- assert.equal( div.is(":animated"), false, ":animated doesn't match" );
+ assert.equal( div.is( ":animated" ), false, ":animated doesn't match" );
// cleanup
div.remove();
+
// leaves a "shadow timer" which does nothing around, need to force a tick
jQuery.fx.tick();
-});
+} );
QUnit.test( ".finish( false ) - unqueued animations", function( assert ) {
var animations = {
@@ -2085,7 +2100,7 @@ QUnit.test( ".finish( false ) - unqueued animations", function( assert ) {
height: 100,
width: 100
},
- div = jQuery("
");
+ div = jQuery( "
" );
assert.expect( 10 );
@@ -2097,20 +2112,21 @@ QUnit.test( ".finish( false ) - unqueued animations", function( assert ) {
complete: function() {
assert.ok( true, "Called animation callback for " + prop );
}
- });
- });
+ } );
+ } );
assert.equal( div.queue().length, 0, "0 animations in the queue" );
div.finish( false );
jQuery.each( animations, function( prop, value ) {
assert.equal( parseFloat( div.css( prop ) ), value, prop + " finished at correct value" );
- });
- assert.equal( div.is(":animated"), false, ":animated doesn't match" );
+ } );
+ assert.equal( div.is( ":animated" ), false, ":animated doesn't match" );
// cleanup
div.remove();
+
// leaves a "shadow timer" which does nothing around, need to force a tick
jQuery.fx.tick();
-});
+} );
QUnit.test( ".finish( \"custom\" ) - custom queue animations", function( assert ) {
var animations = {
@@ -2119,7 +2135,7 @@ QUnit.test( ".finish( \"custom\" ) - custom queue animations", function( assert
height: 100,
width: 100
},
- div = jQuery("
");
+ div = jQuery( "
" );
assert.expect( 11 );
@@ -2131,30 +2147,32 @@ QUnit.test( ".finish( \"custom\" ) - custom queue animations", function( assert
complete: function() {
assert.ok( true, "Called animation callback for " + prop );
}
- });
- });
+ } );
+ } );
assert.equal( div.queue( "custom" ).length, 4, "4 animations in the queue" );
+
// start the first animation
div.dequeue( "custom" );
- assert.equal( div.is(":animated"), true, ":animated matches" );
+ assert.equal( div.is( ":animated" ), true, ":animated matches" );
div.finish( "custom" );
jQuery.each( animations, function( prop, value ) {
assert.equal( parseFloat( div.css( prop ) ), value, prop + " finished at correct value" );
- });
- assert.equal( div.is(":animated"), false, ":animated doesn't match" );
+ } );
+ assert.equal( div.is( ":animated" ), false, ":animated doesn't match" );
// cleanup
div.remove();
+
// leaves a "shadow timer" which does nothing around, need to force a tick
jQuery.fx.tick();
-});
+} );
QUnit.test( ".finish() calls finish of custom queue functions", function( assert ) {
function queueTester( next, hooks ) {
hooks.stop = function( gotoEnd ) {
inside++;
- assert.equal( this, div[0] );
- assert.ok( gotoEnd, "hooks.stop(true) called");
+ assert.equal( this, div[ 0 ] );
+ assert.ok( gotoEnd, "hooks.stop(true) called" );
};
}
var div = jQuery( "
" ),
@@ -2173,15 +2191,15 @@ QUnit.test( ".finish() calls finish of custom queue functions", function( assert
assert.equal( outside, 2, "2 finish callbacks" );
div.remove();
-});
+} );
QUnit.test( ".finish() is applied correctly when multiple elements were animated (#13937)", function( assert ) {
assert.expect( 3 );
- var elems = jQuery("
0 1 2 ");
+ var elems = jQuery( "
0 1 2 " );
elems.animate( { opacity: 0 }, 1500 ).animate( { opacity: 1 }, 1500 );
- setTimeout(function() {
+ setTimeout( function() {
elems.eq( 1 ).finish();
assert.ok( !elems.eq( 1 ).queue().length, "empty queue for .finish()ed element" );
assert.ok( elems.eq( 0 ).queue().length, "non-empty queue for preceding element" );
@@ -2190,13 +2208,13 @@ QUnit.test( ".finish() is applied correctly when multiple elements were animated
}, 100 );
this.clock.tick( 1500 );
-});
+} );
QUnit.test( "slideDown() after stop() (#13483)", function( assert ) {
assert.expect( 2 );
var ul = jQuery( "
" )
- .appendTo("#qunit-fixture"),
+ .appendTo( "#qunit-fixture" ),
origHeight = ul.height(),
clock = this.clock;
@@ -2220,10 +2238,10 @@ QUnit.test( "slideDown() after stop() (#13483)", function( assert ) {
ul.remove();
clock.tick( 10 );
- });
+ } );
clock.tick( 10 );
-});
+} );
QUnit.test( "Respect display value on inline elements (#14824)", function( assert ) {
assert.expect( 2 );
@@ -2234,22 +2252,22 @@ QUnit.test( "Respect display value on inline elements (#14824)", function( asser
jQuery( "#qunit-fixture" ).append( fromStyleSheet, fromStyleAttr );
- fromStyleSheet.slideUp(function() {
+ fromStyleSheet.slideUp( function() {
jQuery( this ).slideDown( function() {
assert.equal( jQuery( this ).css( "display" ), "block",
"Respect previous display value (from stylesheet) on span element" );
- });
- });
+ } );
+ } );
fromStyleAttr.slideUp( function() {
jQuery( this ).slideDown( function() {
assert.equal( jQuery( this ).css( "display" ), "block",
"Respect previous display value (from style attribute) on span element" );
- });
- });
+ } );
+ } );
clock.tick( 800 );
-});
+} );
QUnit.test( "jQuery.easing._default (gh-2218)", function( assert ) {
assert.expect( 2 );
@@ -2261,7 +2279,7 @@ QUnit.test( "jQuery.easing._default (gh-2218)", function( assert ) {
assert.equal( anim.opts.easing, jQuery.easing._default,
"anim.opts.easing should be equal to jQuery.easing._default when the easing argument is not given" );
}
- })
+ } )
.animate( { height: "5px" }, {
duration: 5,
easing: "linear",
@@ -2269,11 +2287,11 @@ QUnit.test( "jQuery.easing._default (gh-2218)", function( assert ) {
assert.equal( anim.opts.easing, "linear",
"anim.opts.easing should be equal to the easing argument" );
}
- })
+ } )
.stop();
this.clock.tick( 25 );
-});
+} );
QUnit.test( "jQuery.easing._default in Animation (gh-2218", function( assert ) {
assert.expect( 3 );
@@ -2298,10 +2316,10 @@ QUnit.test( "jQuery.easing._default in Animation (gh-2218", function( assert ) {
"Animation used custom jQuery.easing._default" );
jQuery.easing._default = defaultEasing;
delete jQuery.easing.custom;
- });
+ } );
this.clock.tick( 10 );
-});
+} );
QUnit.test( "jQuery.easing._default in Tween (gh-2218)", function( assert ) {
assert.expect( 3 );
@@ -2325,33 +2343,33 @@ QUnit.test( "jQuery.easing._default in Tween (gh-2218)", function( assert ) {
"Animation used custom jQuery.easing._default" );
jQuery.easing._default = defaultEasing;
delete jQuery.easing.custom;
-});
+} );
QUnit.test( "Display value is correct for disconnected nodes (trac-13310)", function( assert ) {
assert.expect( 3 );
- var div = jQuery("
");
+ var div = jQuery( "
" );
- assert.equal( div.css( "display", "inline" ).hide().show().appendTo("body").css( "display" ), "inline", "Initialized display value has returned" );
+ assert.equal( div.css( "display", "inline" ).hide().show().appendTo( "body" ).css( "display" ), "inline", "Initialized display value has returned" );
div.remove();
div.css( "display", "none" ).hide();
assert.equal( jQuery._data( div[ 0 ], "olddisplay" ), undefined, "olddisplay is undefined after hiding a detached and hidden element" );
div.remove();
- div.css( "display", "inline-block" ).hide().appendTo("body").fadeIn(function() {
+ div.css( "display", "inline-block" ).hide().appendTo( "body" ).fadeIn( function() {
assert.equal( div.css( "display" ), "inline-block", "Initialized display value has returned" );
div.remove();
- });
+ } );
this.clock.tick( 1000 );
-});
+} );
QUnit.test( "Show/hide/toggle and display: inline", function( assert ) {
assert.expect( 40 );
var clock = this.clock;
- jQuery( "
" ).each(function() {
+ jQuery( "
" ).each( function() {
var completed, interrupted,
N = 100,
fixture = jQuery( "#qunit-fixture" ),
@@ -2360,59 +2378,59 @@ QUnit.test( "Show/hide/toggle and display: inline", function( assert ) {
// Animations allowed to complete
completed = jQuery.map( [
- $el.clone().data({ call: "hide", done: "none" }).appendTo( fixture ).hide( N ),
- $el.clone().data({ call: "toggle", done: "none" }).appendTo( fixture ).toggle( N ),
- $el.clone().data({ call: "hide+show", done: "inline" }).appendTo( fixture )
+ $el.clone().data( { call: "hide", done: "none" } ).appendTo( fixture ).hide( N ),
+ $el.clone().data( { call: "toggle", done: "none" } ).appendTo( fixture ).toggle( N ),
+ $el.clone().data( { call: "hide+show", done: "inline" } ).appendTo( fixture )
.hide().show( N ),
- $el.clone().data({ call: "hide+toggle", done: "inline" }).appendTo( fixture )
+ $el.clone().data( { call: "hide+toggle", done: "inline" } ).appendTo( fixture )
.hide().toggle( N )
], function( $clone ) { return $clone[ 0 ]; } );
// Animations not allowed to complete
interrupted = jQuery.map( [
- $el.clone().data({ call: "hide+stop" }).appendTo( fixture ).hide( N ),
- $el.clone().data({ call: "toggle+stop" }).appendTo( fixture ).toggle( N ),
- $el.clone().data({ call: "hide+show+stop" }).appendTo( fixture ).hide().show( N ),
- $el.clone().data({ call: "hide+toggle+stop" }).appendTo( fixture ).hide().toggle( N )
+ $el.clone().data( { call: "hide+stop" } ).appendTo( fixture ).hide( N ),
+ $el.clone().data( { call: "toggle+stop" } ).appendTo( fixture ).toggle( N ),
+ $el.clone().data( { call: "hide+show+stop" } ).appendTo( fixture ).hide().show( N ),
+ $el.clone().data( { call: "hide+toggle+stop" } ).appendTo( fixture ).hide().toggle( N )
], function( $clone ) { return $clone[ 0 ]; } );
// All elements should be inline-block during the animation
clock.tick( N / 2 );
- jQuery( completed ).each(function() {
+ jQuery( completed ).each( function() {
var $el = jQuery( this ),
call = $el.data( "call" );
assert.strictEqual( $el.css( "display" ), "inline-block", kind + " display during " + call );
- });
+ } );
// Interrupted elements should remain inline-block
jQuery( interrupted ).stop();
clock.tick( N / 2 );
- jQuery( interrupted ).each(function() {
+ jQuery( interrupted ).each( function() {
var $el = jQuery( this ),
call = $el.data( "call" );
assert.strictEqual( $el.css( "display" ), "inline-block", kind + " display after " + call );
- });
+ } );
// Completed elements should not remain inline-block
clock.tick( N / 2 );
- jQuery( completed ).each(function() {
+ jQuery( completed ).each( function() {
var $el = jQuery( this ),
call = $el.data( "call" ),
display = $el.data( "done" );
assert.strictEqual( $el.css( "display" ), display, kind + " display after " + call );
- });
+ } );
// A post-animation toggle should not make any element inline-block
completed = jQuery( completed.concat( interrupted ) );
completed.toggle( N / 2 );
clock.tick( N );
- completed.each(function() {
+ completed.each( function() {
var $el = jQuery( this ),
call = $el.data( "call" );
assert.ok( $el.css( "display" ) !== "inline-block",
kind + " display is not inline-block after " + call + "+toggle" );
- });
- });
-});
+ } );
+ } );
+} );
-})();
+} )();
diff --git a/test/unit/event.js b/test/unit/event.js
index 8b0976721..6f4e6824e 100644
--- a/test/unit/event.js
+++ b/test/unit/event.js
@@ -3,28 +3,28 @@ QUnit.module( "event", {
document.body.focus();
},
teardown: moduleTeardown
-});
+} );
-QUnit.test("on() with non-null,defined data", function( assert ) {
+QUnit.test( "on() with non-null,defined data", function( assert ) {
- assert.expect(2);
+ assert.expect( 2 );
var handler = function( event, data ) {
assert.equal( data, 0, "non-null, defined data (zero) is correctly passed" );
};
- jQuery("#foo").on("foo.on", handler);
- jQuery("div").on("foo.delegate", "#foo", handler);
+ jQuery( "#foo" ).on( "foo.on", handler );
+ jQuery( "div" ).on( "foo.delegate", "#foo", handler );
- jQuery("#foo").trigger("foo", 0);
+ jQuery( "#foo" ).trigger( "foo", 0 );
- jQuery("#foo").off("foo.on", handler);
- jQuery("div").off("foo.delegate", "#foo");
+ jQuery( "#foo" ).off( "foo.on", handler );
+ jQuery( "div" ).off( "foo.delegate", "#foo" );
-});
+} );
-QUnit.test("Handler changes and .trigger() order", function( assert ) {
- assert.expect(1);
+QUnit.test( "Handler changes and .trigger() order", function( assert ) {
+ assert.expect( 1 );
var markup = jQuery(
"
"
@@ -34,154 +34,154 @@ QUnit.test("Handler changes and .trigger() order", function( assert ) {
markup
.find( "*" ).addBack().on( "click", function() {
path += this.nodeName.toLowerCase() + " ";
- })
+ } )
.filter( "b" ).on( "click", function( e ) {
+
// Removing span should not stop propagation to original parents
if ( e.target === this ) {
- jQuery(this).parent().remove();
+ jQuery( this ).parent().remove();
}
- });
+ } );
markup.find( "b" ).trigger( "click" );
assert.equal( path, "b p div div ", "Delivered all events" );
markup.remove();
-});
+} );
-QUnit.test("on(), with data", function( assert ) {
- assert.expect(4);
+QUnit.test( "on(), with data", function( assert ) {
+ assert.expect( 4 );
var test, handler, handler2;
- handler = function(event) {
+ handler = function( event ) {
assert.ok( event.data, "on() with data, check passed data exists" );
- assert.equal( event.data["foo"], "bar", "on() with data, Check value of passed data" );
+ assert.equal( event.data[ "foo" ], "bar", "on() with data, Check value of passed data" );
};
- jQuery("#firstp").on("click", {"foo": "bar"}, handler).trigger("click").off("click", handler);
+ jQuery( "#firstp" ).on( "click", { "foo": "bar" }, handler ).trigger( "click" ).off( "click", handler );
- assert.ok( !jQuery._data(jQuery("#firstp")[0], "events"), "Event handler unbound when using data." );
+ assert.ok( !jQuery._data( jQuery( "#firstp" )[ 0 ], "events" ), "Event handler unbound when using data." );
- test = function(){};
- handler2 = function(event) {
+ test = function() {};
+ handler2 = function( event ) {
assert.equal( event.data, test, "on() with function data, Check value of passed data" );
};
- jQuery("#firstp").on("click", test, handler2).trigger("click").off("click", handler2);
-});
+ jQuery( "#firstp" ).on( "click", test, handler2 ).trigger( "click" ).off( "click", handler2 );
+} );
-QUnit.test("click(), with data", function( assert ) {
- assert.expect(3);
- var handler = function(event) {
+QUnit.test( "click(), with data", function( assert ) {
+ assert.expect( 3 );
+ var handler = function( event ) {
assert.ok( event.data, "on() with data, check passed data exists" );
- assert.equal( event.data["foo"], "bar", "on() with data, Check value of passed data" );
+ assert.equal( event.data[ "foo" ], "bar", "on() with data, Check value of passed data" );
};
- jQuery("#firstp").on( "click", {"foo": "bar"}, handler).trigger("click").off("click", handler);
+ jQuery( "#firstp" ).on( "click", { "foo": "bar" }, handler ).trigger( "click" ).off( "click", handler );
- assert.ok( !jQuery._data(jQuery("#firstp")[0], "events"), "Event handler unbound when using data." );
-});
+ assert.ok( !jQuery._data( jQuery( "#firstp" )[ 0 ], "events" ), "Event handler unbound when using data." );
+} );
-QUnit.test("on(), with data, trigger with data", function( assert ) {
- assert.expect(4);
- var handler = function(event, data) {
+QUnit.test( "on(), with data, trigger with data", function( assert ) {
+ assert.expect( 4 );
+ var handler = function( event, data ) {
assert.ok( event.data, "check passed data exists" );
assert.equal( event.data.foo, "bar", "Check value of passed data" );
assert.ok( data, "Check trigger data" );
assert.equal( data.bar, "foo", "Check value of trigger data" );
};
- jQuery("#firstp").on("click", {foo: "bar"}, handler).trigger("click", [{bar: "foo"}]).off("click", handler);
-});
+ jQuery( "#firstp" ).on( "click", { foo: "bar" }, handler ).trigger( "click", [ { bar: "foo" } ] ).off( "click", handler );
+} );
-QUnit.test("on(), multiple events at once", function( assert ) {
- assert.expect(2);
+QUnit.test( "on(), multiple events at once", function( assert ) {
+ assert.expect( 2 );
var handler,
clickCounter = 0,
mouseoverCounter = 0;
- handler = function(event) {
- if (event.type === "click") {
+ handler = function( event ) {
+ if ( event.type === "click" ) {
clickCounter += 1;
- }
- else if (event.type === "mouseover") {
+ } else if ( event.type === "mouseover" ) {
mouseoverCounter += 1;
}
};
- jQuery("#firstp").on("click mouseover", handler).trigger("click").trigger("mouseover");
+ jQuery( "#firstp" ).on( "click mouseover", handler ).trigger( "click" ).trigger( "mouseover" );
assert.equal( clickCounter, 1, "on() with multiple events at once" );
assert.equal( mouseoverCounter, 1, "on() with multiple events at once" );
-});
+} );
-QUnit.test("on(), five events at once", function( assert ) {
- assert.expect(1);
+QUnit.test( "on(), five events at once", function( assert ) {
+ assert.expect( 1 );
var count = 0,
handler = function() {
count++;
};
- jQuery("#firstp").on("click mouseover foo bar baz", handler)
- .trigger("click").trigger("mouseover")
- .trigger("foo").trigger("bar")
- .trigger("baz");
+ jQuery( "#firstp" ).on( "click mouseover foo bar baz", handler )
+ .trigger( "click" ).trigger( "mouseover" )
+ .trigger( "foo" ).trigger( "bar" )
+ .trigger( "baz" );
assert.equal( count, 5, "on() five events at once" );
-});
+} );
-QUnit.test("on(), multiple events at once and namespaces", function( assert ) {
- assert.expect(7);
+QUnit.test( "on(), multiple events at once and namespaces", function( assert ) {
+ assert.expect( 7 );
var cur, div,
obj = {};
- div = jQuery("
").on("focusin.a", function(e) {
+ div = jQuery( "
" ).on( "focusin.a", function( e ) {
assert.equal( e.type, cur, "Verify right single event was fired." );
- });
+ } );
cur = "focusin";
- div.trigger("focusin.a");
+ div.trigger( "focusin.a" );
// manually clean up detached elements
div.remove();
- div = jQuery("
").on("click mouseover", obj, function(e) {
+ div = jQuery( "
" ).on( "click mouseover", obj, function( e ) {
assert.equal( e.type, cur, "Verify right multi event was fired." );
assert.equal( e.data, obj, "Make sure the data came in correctly." );
- });
+ } );
cur = "click";
- div.trigger("click");
+ div.trigger( "click" );
cur = "mouseover";
- div.trigger("mouseover");
+ div.trigger( "mouseover" );
// manually clean up detached elements
div.remove();
- div = jQuery("
").on("focusin.a focusout.b", function(e) {
+ div = jQuery( "
" ).on( "focusin.a focusout.b", function( e ) {
assert.equal( e.type, cur, "Verify right multi event was fired." );
- });
+ } );
cur = "focusin";
- div.trigger("focusin.a");
+ div.trigger( "focusin.a" );
cur = "focusout";
- div.trigger("focusout.b");
+ div.trigger( "focusout.b" );
// manually clean up detached elements
div.remove();
-});
+} );
-QUnit.test("on(), namespace with special add", function( assert ) {
- assert.expect(27);
+QUnit.test( "on(), namespace with special add", function( assert ) {
+ assert.expect( 27 );
var i = 0,
- div = jQuery("
").appendTo("#qunit-fixture").on( "test", function() {
+ div = jQuery( "
" ).appendTo( "#qunit-fixture" ).on( "test", function() {
assert.ok( true, "Test event fired." );
- });
+ } );
- jQuery.event.special["test"] = {
+ jQuery.event.special[ "test" ] = {
_default: function( e, data ) {
assert.equal( e.type, "test", "Make sure we're dealing with a test event." );
assert.ok( data, "And that trigger data was passed." );
- assert.strictEqual( e.target, div[0], "And that the target is correct." );
+ assert.strictEqual( e.target, div[ 0 ], "And that the target is correct." );
assert.equal( this, window, "And that the context is correct." );
},
setup: function() {},
@@ -202,13 +202,13 @@ QUnit.test("on(), namespace with special add", function( assert ) {
div.on( "test.a", { x: 1 }, function( e ) {
assert.ok( !!e.xyz, "Make sure that the data is getting passed through." );
- assert.equal( e.data["x"], 1, "Make sure data is attached properly." );
- });
+ assert.equal( e.data[ "x" ], 1, "Make sure data is attached properly." );
+ } );
div.on( "test.b", { x: 2 }, function( e ) {
assert.ok( !!e.xyz, "Make sure that the data is getting passed through." );
- assert.equal( e.data["x"], 2, "Make sure data is attached properly." );
- });
+ assert.equal( e.data[ "x" ], 2, "Make sure data is attached properly." );
+ } );
// Should trigger 5
div.trigger( "test", 33.33 );
@@ -220,61 +220,63 @@ QUnit.test("on(), namespace with special add", function( assert ) {
div.trigger( "test.b", { year: 1982 } );
// Should trigger 4
- div.off("test");
+ div.off( "test" );
- div = jQuery("
").on( "test", function() {
+ div = jQuery( "
" ).on( "test", function() {
assert.ok( true, "Test event fired." );
- });
+ } );
// Should trigger 2
- div.appendTo("#qunit-fixture").remove();
+ div.appendTo( "#qunit-fixture" ).remove();
- delete jQuery.event.special["test"];
-});
+ delete jQuery.event.special[ "test" ];
+} );
-QUnit.test("on(), no data", function( assert ) {
- assert.expect(1);
- var handler = function(event) {
+QUnit.test( "on(), no data", function( assert ) {
+ assert.expect( 1 );
+ var handler = function( event ) {
ok ( !event.data, "Check that no data is added to the event object" );
};
- jQuery("#firstp").on("click", handler).trigger("click");
-});
+ jQuery( "#firstp" ).on( "click", handler ).trigger( "click" );
+} );
-QUnit.test("on/one/off(Object)", function( assert ){
- assert.expect(6);
+QUnit.test( "on/one/off(Object)", function( assert ) {
+ assert.expect( 6 );
var $elem,
clickCounter = 0,
mouseoverCounter = 0;
- function handler(event) {
- if (event.type === "click") {
+ function handler( event ) {
+ if ( event.type === "click" ) {
clickCounter++;
- } else if (event.type === "mouseover") {
+ } else if ( event.type === "mouseover" ) {
mouseoverCounter++;
}
}
- function handlerWithData(event) {
- if (event.type === "click") {
+ function handlerWithData( event ) {
+ if ( event.type === "click" ) {
clickCounter += event.data;
- } else if (event.type === "mouseover") {
+ } else if ( event.type === "mouseover" ) {
mouseoverCounter += event.data;
}
}
- function trigger(){
- $elem.trigger("click").trigger("mouseover");
+ function trigger() {
+ $elem.trigger( "click" ).trigger( "mouseover" );
}
- $elem = jQuery("#firstp")
+ $elem = jQuery( "#firstp" )
+
// Regular bind
- .on({
+ .on( {
"click":handler,
"mouseover":handler
- })
+ } )
+
// Bind with data
- .one({
+ .one( {
"click":handlerWithData,
"mouseover":handlerWithData
}, 2 );
@@ -288,24 +290,24 @@ QUnit.test("on/one/off(Object)", function( assert ){
assert.equal( clickCounter, 4, "on(Object)" );
assert.equal( mouseoverCounter, 4, "on(Object)" );
- jQuery("#firstp").off({
+ jQuery( "#firstp" ).off( {
"click":handler,
"mouseover":handler
- });
+ } );
trigger();
assert.equal( clickCounter, 4, "on(Object)" );
assert.equal( mouseoverCounter, 4, "on(Object)" );
-});
+} );
-QUnit.test("on/off(Object), on/off(Object, String)", function( assert ) {
- assert.expect(6);
+QUnit.test( "on/off(Object), on/off(Object, String)", function( assert ) {
+ assert.expect( 6 );
var events,
clickCounter = 0,
mouseoverCounter = 0,
- $p = jQuery("#firstp"),
- $a = $p.find("a").eq(0);
+ $p = jQuery( "#firstp" ),
+ $a = $p.find( "a" ).eq( 0 );
events = {
"click": function( event ) {
@@ -317,7 +319,7 @@ QUnit.test("on/off(Object), on/off(Object, String)", function( assert ) {
};
function trigger() {
- $a.trigger("click").trigger("mouseover");
+ $a.trigger( "click" ).trigger( "mouseover" );
}
jQuery( document ).on( events, "#firstp a" );
@@ -338,41 +340,41 @@ QUnit.test("on/off(Object), on/off(Object, String)", function( assert ) {
trigger();
assert.equal( clickCounter, 4, "off" );
assert.equal( mouseoverCounter, 4, "off" );
-});
+} );
-QUnit.test("on immediate propagation", function( assert ) {
- assert.expect(2);
+QUnit.test( "on immediate propagation", function( assert ) {
+ assert.expect( 2 );
var lastClick,
- $p = jQuery("#firstp"),
- $a = $p.find("a").eq(0);
+ $p = jQuery( "#firstp" ),
+ $a = $p.find( "a" ).eq( 0 );
lastClick = "";
- jQuery( document ).on( "click", "#firstp a", function(e) {
+ jQuery( document ).on( "click", "#firstp a", function( e ) {
lastClick = "click1";
e.stopImmediatePropagation();
- });
+ } );
jQuery( document ).on( "click", "#firstp a", function() {
lastClick = "click2";
- });
+ } );
$a.trigger( "click" );
assert.equal( lastClick, "click1", "on stopImmediatePropagation" );
jQuery( document ).off( "click", "#firstp a" );
lastClick = "";
- $p.on( "click", "a", function(e) {
+ $p.on( "click", "a", function( e ) {
lastClick = "click1";
e.stopImmediatePropagation();
- });
+ } );
$p.on( "click", "a", function() {
lastClick = "click2";
- });
+ } );
$a.trigger( "click" );
assert.equal( lastClick, "click1", "on stopImmediatePropagation" );
$p.off( "click", "**" );
-});
+} );
-QUnit.test("on bubbling, isDefaultPrevented, stopImmediatePropagation", function( assert ) {
+QUnit.test( "on bubbling, isDefaultPrevented, stopImmediatePropagation", function( assert ) {
assert.expect( 3 );
var $anchor2 = jQuery( "#anchor2" ),
@@ -380,27 +382,29 @@ QUnit.test("on bubbling, isDefaultPrevented, stopImmediatePropagation", function
neverCallMe = function() {
assert.ok( false, "immediate propagation should have been stopped" );
},
- fakeClick = function($jq) {
+ fakeClick = function( $jq ) {
+
// Use a native click so we don't get jQuery simulated bubbling
var e = document.createEvent( "MouseEvents" );
e.initEvent( "click", true, true );
$jq[ 0 ].dispatchEvent( e );
};
- $anchor2.on( "click", function(e) {
+ $anchor2.on( "click", function( e ) {
e.preventDefault();
- });
+ } );
$main.on( "click", "#foo", function( e ) {
assert.equal( e.isDefaultPrevented(), true, "isDefaultPrevented true passed to bubbled event" );
- });
+ } );
fakeClick( $anchor2 );
$anchor2.off( "click" );
$main.off( "click", "**" );
$anchor2.on( "click", function() {
+
// Let the default action occur
- });
- $main.on("click", "#foo", function(e) {
+ } );
+ $main.on( "click", "#foo", function( e ) {
assert.equal( e.isDefaultPrevented(), false, "isDefaultPrevented false passed to bubbled event" );
- });
+ } );
fakeClick( $anchor2 );
$anchor2.off( "click" );
$main.off( "click", "**" );
@@ -414,91 +418,91 @@ QUnit.test("on bubbling, isDefaultPrevented, stopImmediatePropagation", function
$anchor2.on( "click", function( e ) {
e.stopImmediatePropagation();
assert.ok( true, "anchor was clicked and prop stopped" );
- });
- $anchor2[0].addEventListener( "click", neverCallMe, false );
+ } );
+ $anchor2[ 0 ].addEventListener( "click", neverCallMe, false );
fakeClick( $anchor2 );
- $anchor2[0].removeEventListener( "click", neverCallMe );
+ $anchor2[ 0 ].removeEventListener( "click", neverCallMe );
}
-});
+} );
-QUnit.test("on(), iframes", function( assert ) {
+QUnit.test( "on(), iframes", function( assert ) {
assert.expect( 1 );
// events don't work with iframes, see #939 - this test fails in IE because of contentDocument
- var doc = jQuery("#loadediframe").contents();
+ var doc = jQuery( "#loadediframe" ).contents();
- jQuery("div", doc).on("click", function() {
+ jQuery( "div", doc ).on( "click", function() {
assert.ok( true, "Binding to element inside iframe" );
- }).trigger("click").off("click");
-});
+ } ).trigger( "click" ).off( "click" );
+} );
-QUnit.test("on(), trigger change on select", function( assert ) {
- assert.expect(5);
+QUnit.test( "on(), trigger change on select", function( assert ) {
+ assert.expect( 5 );
var counter = 0;
- function selectOnChange(event) {
+ function selectOnChange( event ) {
assert.equal( event.data, counter++, "Event.data is not a global event object" );
}
- jQuery("#form select").each(function(i){
- jQuery(this).on("change", i, selectOnChange);
- }).trigger("change");
-});
+ jQuery( "#form select" ).each( function( i ) {
+ jQuery( this ).on( "change", i, selectOnChange );
+ } ).trigger( "change" );
+} );
-QUnit.test("on(), namespaced events, cloned events", function( assert ) {
+QUnit.test( "on(), namespaced events, cloned events", function( assert ) {
assert.expect( 18 );
var firstp = jQuery( "#firstp" );
- firstp.on("custom.test",function(){
- assert.ok(false, "Custom event triggered");
- });
+ firstp.on( "custom.test", function() {
+ assert.ok( false, "Custom event triggered" );
+ } );
- firstp.on("click",function(e){
- assert.ok(true, "Normal click triggered");
+ firstp.on( "click", function( e ) {
+ assert.ok( true, "Normal click triggered" );
assert.equal( e.type + e.namespace, "click", "Check that only click events trigger this fn" );
- });
+ } );
- firstp.on("click.test",function(e){
+ firstp.on( "click.test", function( e ) {
var check = "click";
assert.ok( true, "Namespaced click triggered" );
if ( e.namespace ) {
check += "test";
}
assert.equal( e.type + e.namespace, check, "Check that only click/click.test events trigger this fn" );
- });
+ } );
//clone(true) element to verify events are cloned correctly
firstp = firstp.add( firstp.clone( true ).attr( "id", "firstp2" ).insertBefore( firstp ) );
// Trigger both bound fn (8)
- firstp.trigger("click");
+ firstp.trigger( "click" );
// Trigger one bound fn (4)
- firstp.trigger("click.test");
+ firstp.trigger( "click.test" );
// Remove only the one fn
- firstp.off("click.test");
+ firstp.off( "click.test" );
// Trigger the remaining fn (4)
- firstp.trigger("click");
+ firstp.trigger( "click" );
// Remove the remaining namespaced fn
- firstp.off(".test");
+ firstp.off( ".test" );
// Try triggering the custom event (0)
- firstp.trigger("custom");
+ firstp.trigger( "custom" );
// using contents will get comments regular, text, and comment nodes
- jQuery("#nonnodes").contents().on("tester", function () {
- assert.equal(this.nodeType, 1, "Check node,textnode,comment on just does real nodes" );
- }).trigger("tester");
+ jQuery( "#nonnodes" ).contents().on( "tester", function() {
+ assert.equal( this.nodeType, 1, "Check node,textnode,comment on just does real nodes" );
+ } ).trigger( "tester" );
// Make sure events stick with appendTo'd elements (which are cloned) #2027
- jQuery("
test ").on( "click", function(){ return false; }).appendTo("#qunit-fixture");
- assert.ok( jQuery("a.test").eq(0).triggerHandler("click") === false, "Handler is bound to appendTo'd elements" );
-});
+ jQuery( "
test " ).on( "click", function() { return false; } ).appendTo( "#qunit-fixture" );
+ assert.ok( jQuery( "a.test" ).eq( 0 ).triggerHandler( "click" ) === false, "Handler is bound to appendTo'd elements" );
+} );
-QUnit.test("on(), multi-namespaced events", function( assert ) {
- assert.expect(6);
+QUnit.test( "on(), multi-namespaced events", function( assert ) {
+ assert.expect( 6 );
var order = [
"click.test.abc",
@@ -509,120 +513,120 @@ QUnit.test("on(), multi-namespaced events", function( assert ) {
"custom.test2"
];
- function check(name, msg){
+ function check( name, msg ) {
assert.deepEqual( name, order.shift(), msg );
}
- jQuery("#firstp").on("custom.test",function() {
- check("custom.test", "Custom event triggered");
- });
+ jQuery( "#firstp" ).on( "custom.test", function() {
+ check( "custom.test", "Custom event triggered" );
+ } );
- jQuery("#firstp").on("custom.test2",function() {
- check("custom.test2", "Custom event triggered");
- });
+ jQuery( "#firstp" ).on( "custom.test2", function() {
+ check( "custom.test2", "Custom event triggered" );
+ } );
- jQuery("#firstp").on("click.test",function() {
- check("click.test", "Normal click triggered");
- });
+ jQuery( "#firstp" ).on( "click.test", function() {
+ check( "click.test", "Normal click triggered" );
+ } );
- jQuery("#firstp").on("click.test.abc",function() {
- check("click.test.abc", "Namespaced click triggered");
- });
+ jQuery( "#firstp" ).on( "click.test.abc", function() {
+ check( "click.test.abc", "Namespaced click triggered" );
+ } );
// Those would not trigger/off (#5303)
- jQuery("#firstp").trigger("click.a.test");
- jQuery("#firstp").off("click.a.test");
+ jQuery( "#firstp" ).trigger( "click.a.test" );
+ jQuery( "#firstp" ).off( "click.a.test" );
// Trigger both bound fn (1)
- jQuery("#firstp").trigger("click.test.abc");
+ jQuery( "#firstp" ).trigger( "click.test.abc" );
// Trigger one bound fn (1)
- jQuery("#firstp").trigger("click.abc");
+ jQuery( "#firstp" ).trigger( "click.abc" );
// Trigger two bound fn (2)
- jQuery("#firstp").trigger("click.test");
+ jQuery( "#firstp" ).trigger( "click.test" );
// Remove only the one fn
- jQuery("#firstp").off("click.abc");
+ jQuery( "#firstp" ).off( "click.abc" );
// Trigger the remaining fn (1)
- jQuery("#firstp").trigger("click");
+ jQuery( "#firstp" ).trigger( "click" );
// Remove the remaining fn
- jQuery("#firstp").off(".test");
+ jQuery( "#firstp" ).off( ".test" );
// Trigger the remaining fn (1)
- jQuery("#firstp").trigger("custom");
-});
+ jQuery( "#firstp" ).trigger( "custom" );
+} );
-QUnit.test("namespace-only event binding is a no-op", function( assert ){
- assert.expect(2);
+QUnit.test( "namespace-only event binding is a no-op", function( assert ) {
+ assert.expect( 2 );
- jQuery("#firstp")
+ jQuery( "#firstp" )
.on( ".whoops", function() {
assert.ok( false, "called a namespace-only event" );
- })
+ } )
.on( "whoops", function() {
assert.ok( true, "called whoops" );
- })
- .trigger("whoops") // 1
- .off(".whoops")
- .trigger("whoops") // 2
- .off("whoops");
-});
+ } )
+ .trigger( "whoops" ) // 1
+ .off( ".whoops" )
+ .trigger( "whoops" ) // 2
+ .off( "whoops" );
+} );
-QUnit.test("Empty namespace is ignored", function( assert ){
+QUnit.test( "Empty namespace is ignored", function( assert ) {
assert.expect( 1 );
- jQuery("#firstp")
+ jQuery( "#firstp" )
.on( "meow.", function( e ) {
assert.equal( e.namespace, "", "triggered a namespace-less meow event" );
- })
- .trigger("meow.")
- .off("meow.");
-});
+ } )
+ .trigger( "meow." )
+ .off( "meow." );
+} );
-QUnit.test("on(), with same function", function( assert ) {
- assert.expect(2);
+QUnit.test( "on(), with same function", function( assert ) {
+ assert.expect( 2 );
- var count = 0, func = function(){
+ var count = 0, func = function() {
count++;
};
- jQuery("#liveHandlerOrder").on("foo.bar", func).on("foo.zar", func);
- jQuery("#liveHandlerOrder").trigger("foo.bar");
+ jQuery( "#liveHandlerOrder" ).on( "foo.bar", func ).on( "foo.zar", func );
+ jQuery( "#liveHandlerOrder" ).trigger( "foo.bar" );
- assert.equal(count, 1, "Verify binding function with multiple namespaces." );
+ assert.equal( count, 1, "Verify binding function with multiple namespaces." );
- jQuery("#liveHandlerOrder").off("foo.bar", func).off("foo.zar", func);
- jQuery("#liveHandlerOrder").trigger("foo.bar");
+ jQuery( "#liveHandlerOrder" ).off( "foo.bar", func ).off( "foo.zar", func );
+ jQuery( "#liveHandlerOrder" ).trigger( "foo.bar" );
- assert.equal(count, 1, "Verify that removing events still work." );
-});
+ assert.equal( count, 1, "Verify that removing events still work." );
+} );
-QUnit.test("on(), make sure order is maintained", function( assert ) {
- assert.expect(1);
+QUnit.test( "on(), make sure order is maintained", function( assert ) {
+ assert.expect( 1 );
- var elem = jQuery("#firstp"), log = [], check = [];
+ var elem = jQuery( "#firstp" ), log = [], check = [];
- jQuery.each( new Array(100), function( i ) {
- elem.on( "click", function(){
+ jQuery.each( new Array( 100 ), function( i ) {
+ elem.on( "click", function() {
log.push( i );
- });
+ } );
check.push( i );
- });
+ } );
- elem.trigger("click");
+ elem.trigger( "click" );
- assert.equal( log.join(","), check.join(","), "Make sure order was maintained." );
+ assert.equal( log.join( "," ), check.join( "," ), "Make sure order was maintained." );
- elem.off("click");
-});
+ elem.off( "click" );
+} );
-QUnit.test("on(), with different this object", function( assert ) {
- assert.expect(4);
+QUnit.test( "on(), with different this object", function( assert ) {
+ assert.expect( 4 );
var thisObject = { myThis: true },
data = { myData: true },
handler1 = function() {
@@ -633,367 +637,369 @@ QUnit.test("on(), with different this object", function( assert ) {
assert.equal( event.data, data, "on() with different this object and data" );
};
- jQuery("#firstp")
- .on("click", jQuery.proxy(handler1, thisObject)).trigger("click").off("click", handler1)
- .on("click", data, jQuery.proxy(handler2, thisObject)).trigger("click").off("click", handler2);
+ jQuery( "#firstp" )
+ .on( "click", jQuery.proxy( handler1, thisObject ) ).trigger( "click" ).off( "click", handler1 )
+ .on( "click", data, jQuery.proxy( handler2, thisObject ) ).trigger( "click" ).off( "click", handler2 );
- assert.ok( !jQuery._data(jQuery("#firstp")[0], "events"), "Event handler unbound when using different this object and data." );
-});
+ assert.ok( !jQuery._data( jQuery( "#firstp" )[ 0 ], "events" ), "Event handler unbound when using different this object and data." );
+} );
-QUnit.test("on(name, false), off(name, false)", function( assert ) {
- assert.expect(3);
+QUnit.test( "on(name, false), off(name, false)", function( assert ) {
+ assert.expect( 3 );
var main = 0;
- jQuery("#qunit-fixture").on("click", function(){ main++; });
- jQuery("#ap").trigger("click");
+ jQuery( "#qunit-fixture" ).on( "click", function() { main++; } );
+ jQuery( "#ap" ).trigger( "click" );
assert.equal( main, 1, "Verify that the trigger happened correctly." );
main = 0;
- jQuery("#ap").on("click", false);
- jQuery("#ap").trigger("click");
+ jQuery( "#ap" ).on( "click", false );
+ jQuery( "#ap" ).trigger( "click" );
assert.equal( main, 0, "Verify that no bubble happened." );
main = 0;
- jQuery("#ap").off("click", false);
- jQuery("#ap").trigger("click");
+ jQuery( "#ap" ).off( "click", false );
+ jQuery( "#ap" ).trigger( "click" );
assert.equal( main, 1, "Verify that the trigger happened correctly." );
// manually clean up events from elements outside the fixture
- jQuery("#qunit-fixture").off("click");
-});
+ jQuery( "#qunit-fixture" ).off( "click" );
+} );
-QUnit.test("on(name, selector, false), off(name, selector, false)", function( assert ) {
- assert.expect(3);
+QUnit.test( "on(name, selector, false), off(name, selector, false)", function( assert ) {
+ assert.expect( 3 );
var main = 0;
- jQuery("#qunit-fixture").on("click", "#ap", function(){ main++; });
- jQuery("#ap").trigger("click");
+ jQuery( "#qunit-fixture" ).on( "click", "#ap", function() { main++; } );
+ jQuery( "#ap" ).trigger( "click" );
assert.equal( main, 1, "Verify that the trigger happened correctly." );
main = 0;
- jQuery("#ap").on("click", "#groups", false);
- jQuery("#groups").trigger("click");
+ jQuery( "#ap" ).on( "click", "#groups", false );
+ jQuery( "#groups" ).trigger( "click" );
assert.equal( main, 0, "Verify that no bubble happened." );
main = 0;
- jQuery("#ap").off("click", "#groups", false);
- jQuery("#groups").trigger("click");
+ jQuery( "#ap" ).off( "click", "#groups", false );
+ jQuery( "#groups" ).trigger( "click" );
assert.equal( main, 1, "Verify that the trigger happened correctly." );
- jQuery("#qunit-fixture").off("click", "#ap");
-});
+ jQuery( "#qunit-fixture" ).off( "click", "#ap" );
+} );
-QUnit.test("on()/trigger()/off() on plain object", function( assert ) {
+QUnit.test( "on()/trigger()/off() on plain object", function( assert ) {
assert.expect( 7 );
var events,
obj = {};
// Make sure it doesn't complain when no events are found
- jQuery(obj).trigger("test");
+ jQuery( obj ).trigger( "test" );
// Make sure it doesn't complain when no events are found
- jQuery(obj).off("test");
+ jQuery( obj ).off( "test" );
- jQuery(obj).on({
+ jQuery( obj ).on( {
"test": function() {
assert.ok( true, "Custom event run." );
},
"submit": function() {
assert.ok( true, "Custom submit event run." );
}
- });
+ } );
- events = jQuery._data(obj, "events");
+ events = jQuery._data( obj, "events" );
assert.ok( events, "Object has events bound." );
- assert.equal( obj["events"], undefined, "Events object on plain objects is not events" );
- assert.equal( obj["test"], undefined, "Make sure that test event is not on the plain object." );
- assert.equal( obj["handle"], undefined, "Make sure that the event handler is not on the plain object." );
+ assert.equal( obj[ "events" ], undefined, "Events object on plain objects is not events" );
+ assert.equal( obj[ "test" ], undefined, "Make sure that test event is not on the plain object." );
+ assert.equal( obj[ "handle" ], undefined, "Make sure that the event handler is not on the plain object." );
// Should trigger 1
- jQuery(obj).trigger("test");
- jQuery(obj).trigger("submit");
+ jQuery( obj ).trigger( "test" );
+ jQuery( obj ).trigger( "submit" );
- jQuery(obj).off("test");
- jQuery(obj).off("submit");
+ jQuery( obj ).off( "test" );
+ jQuery( obj ).off( "submit" );
// Should trigger 0
- jQuery(obj).trigger("test");
+ jQuery( obj ).trigger( "test" );
// Make sure it doesn't complain when no events are found
- jQuery(obj).off("test");
+ jQuery( obj ).off( "test" );
assert.equal( obj && obj[ jQuery.expando ] &&
obj[ jQuery.expando ][ jQuery.expando ] &&
- obj[ jQuery.expando ][ jQuery.expando ]["events"], undefined, "Make sure events object is removed" );
-});
+ obj[ jQuery.expando ][ jQuery.expando ][ "events" ], undefined, "Make sure events object is removed" );
+} );
-QUnit.test("off(type)", function( assert ) {
+QUnit.test( "off(type)", function( assert ) {
assert.expect( 1 );
var message, func,
- $elem = jQuery("#firstp");
+ $elem = jQuery( "#firstp" );
- function error(){
+ function error() {
assert.ok( false, message );
}
message = "unbind passing function";
- $elem.on("error1", error).off("error1", error).triggerHandler("error1");
+ $elem.on( "error1", error ).off( "error1", error ).triggerHandler( "error1" );
message = "unbind all from event";
- $elem.on("error1", error).off("error1").triggerHandler("error1");
+ $elem.on( "error1", error ).off( "error1" ).triggerHandler( "error1" );
message = "unbind all";
- $elem.on("error1", error).off().triggerHandler("error1");
+ $elem.on( "error1", error ).off().triggerHandler( "error1" );
message = "unbind many with function";
- $elem.on("error1 error2",error)
- .off("error1 error2", error )
- .trigger("error1").triggerHandler("error2");
+ $elem.on( "error1 error2", error )
+ .off( "error1 error2", error )
+ .trigger( "error1" ).triggerHandler( "error2" );
message = "unbind many"; // #3538
- $elem.on("error1 error2", error)
- .off("error1 error2")
- .trigger("error1").triggerHandler("error2");
+ $elem.on( "error1 error2", error )
+ .off( "error1 error2" )
+ .trigger( "error1" ).triggerHandler( "error2" );
message = "unbind without a type or handler";
- $elem.on("error1 error2.test",error)
+ $elem.on( "error1 error2.test", error )
.off()
- .trigger("error1").triggerHandler("error2");
+ .trigger( "error1" ).triggerHandler( "error2" );
// Should only unbind the specified function
- jQuery( document ).on( "click", function(){
- assert.ok( true, "called handler after selective removal");
- });
+ jQuery( document ).on( "click", function() {
+ assert.ok( true, "called handler after selective removal" );
+ } );
func = function() {};
jQuery( document )
.on( "click", func )
.off( "click", func )
- .trigger("click")
+ .trigger( "click" )
.off( "click" );
-});
+} );
-QUnit.test("off(eventObject)", function( assert ) {
- assert.expect(4);
+QUnit.test( "off(eventObject)", function( assert ) {
+ assert.expect( 4 );
- var $elem = jQuery("#firstp"),
+ var $elem = jQuery( "#firstp" ),
num;
- function check( expected ){
+ function check( expected ) {
num = 0;
- $elem.trigger("foo").triggerHandler("bar");
+ $elem.trigger( "foo" ).triggerHandler( "bar" );
assert.equal( num, expected, "Check the right handlers are triggered" );
}
$elem
+
// This handler shouldn't be unbound
- .on("foo", function(){
+ .on( "foo", function() {
num += 1;
- })
- .on("foo", function(e){
+ } )
+ .on( "foo", function( e ) {
$elem.off( e );
num += 2;
- })
+ } )
+
// Neither this one
- .on("bar", function(){
+ .on( "bar", function() {
num += 4;
- });
+ } );
check( 7 );
check( 5 );
- $elem.off("bar");
+ $elem.off( "bar" );
check( 1 );
$elem.off();
check( 0 );
-});
+} );
if ( jQuery.fn.hover ) {
- QUnit.test("hover() mouseenter mouseleave", function( assert ) {
- assert.expect(1);
+ QUnit.test( "hover() mouseenter mouseleave", function( assert ) {
+ assert.expect( 1 );
var times = 0,
handler1 = function() { ++times; },
handler2 = function() { ++times; };
- jQuery("#firstp")
- .hover(handler1, handler2)
+ jQuery( "#firstp" )
+ .hover( handler1, handler2 )
.mouseenter().mouseleave()
- .off("mouseenter", handler1)
- .off("mouseleave", handler2)
- .hover(handler1)
+ .off( "mouseenter", handler1 )
+ .off( "mouseleave", handler2 )
+ .hover( handler1 )
.mouseenter().mouseleave()
- .off("mouseenter mouseleave", handler1)
+ .off( "mouseenter mouseleave", handler1 )
.mouseenter().mouseleave();
assert.equal( times, 4, "hover handlers fired" );
- });
+ } );
}
-QUnit.test("mouseover triggers mouseenter", function( assert ) {
- assert.expect(1);
+QUnit.test( "mouseover triggers mouseenter", function( assert ) {
+ assert.expect( 1 );
var count = 0,
- elem = jQuery("
");
- elem.on( "mouseenter", function () {
+ elem = jQuery( "
" );
+ elem.on( "mouseenter", function() {
count++;
- });
- elem.trigger("mouseover");
- assert.equal(count, 1, "make sure mouseover triggers a mouseenter" );
+ } );
+ elem.trigger( "mouseover" );
+ assert.equal( count, 1, "make sure mouseover triggers a mouseenter" );
elem.remove();
-});
+} );
-QUnit.test("pointerover triggers pointerenter", function( assert ) {
- assert.expect(1);
+QUnit.test( "pointerover triggers pointerenter", function( assert ) {
+ assert.expect( 1 );
var count = 0,
- elem = jQuery("
");
- elem.on( "pointerenter", function () {
+ elem = jQuery( "
" );
+ elem.on( "pointerenter", function() {
count++;
- });
- elem.trigger("pointerover");
- assert.equal(count, 1, "make sure pointerover triggers a pointerenter" );
+ } );
+ elem.trigger( "pointerover" );
+ assert.equal( count, 1, "make sure pointerover triggers a pointerenter" );
elem.remove();
-});
+} );
-QUnit.test("withinElement implemented with jQuery.contains()", function( assert ) {
+QUnit.test( "withinElement implemented with jQuery.contains()", function( assert ) {
- assert.expect(1);
+ assert.expect( 1 );
- jQuery("#qunit-fixture").append("
");
+ jQuery( "#qunit-fixture" ).append( "
" );
- jQuery("#jc-outer").on("mouseenter mouseleave", function( event ) {
+ jQuery( "#jc-outer" ).on( "mouseenter mouseleave", function( event ) {
assert.equal( this.id, "jc-outer", this.id + " " + event.type );
- }).trigger("mouseenter");
+ } ).trigger( "mouseenter" );
- jQuery("#jc-inner").trigger("mousenter");
+ jQuery( "#jc-inner" ).trigger( "mousenter" );
- jQuery("#jc-outer").off("mouseenter mouseleave").remove();
- jQuery("#jc-inner").remove();
+ jQuery( "#jc-outer" ).off( "mouseenter mouseleave" ).remove();
+ jQuery( "#jc-inner" ).remove();
-});
+} );
-QUnit.test("mouseenter, mouseleave don't catch exceptions", function( assert ) {
- assert.expect(2);
+QUnit.test( "mouseenter, mouseleave don't catch exceptions", function( assert ) {
+ assert.expect( 2 );
- var elem = jQuery("#firstp").on( "mouseenter mouseleave", function() {
+ var elem = jQuery( "#firstp" ).on( "mouseenter mouseleave", function() {
throw "an Exception";
- });
+ } );
try {
- elem.trigger("mouseenter");
- } catch (e) {
+ elem.trigger( "mouseenter" );
+ } catch ( e ) {
assert.equal( e, "an Exception", "mouseenter doesn't catch exceptions" );
}
try {
- elem.trigger("mouseleave");
- } catch (e) {
+ elem.trigger( "mouseleave" );
+ } catch ( e ) {
assert.equal( e, "an Exception", "mouseleave doesn't catch exceptions" );
}
-});
+} );
if ( jQuery.fn.click ) {
- QUnit.test("trigger() shortcuts", function( assert ) {
- assert.expect(5);
+ QUnit.test( "trigger() shortcuts", function( assert ) {
+ assert.expect( 5 );
var counter, clickCounter,
- elem = jQuery("
Change location ").prependTo("#firstUL");
- elem.find("a").on("click", function() {
- var close = jQuery("spanx", this); // same with jQuery(this).find("span");
+ elem = jQuery( "
Change location " ).prependTo( "#firstUL" );
+ elem.find( "a" ).on( "click", function() {
+ var close = jQuery( "spanx", this ); // same with jQuery(this).find("span");
assert.equal( close.length, 0, "Context element does not exist, length must be zero" );
- assert.ok( !close[0], "Context element does not exist, direct access to element must return undefined" );
+ assert.ok( !close[ 0 ], "Context element does not exist, direct access to element must return undefined" );
return false;
- }).click();
+ } ).click();
// manually clean up detached elements
elem.remove();
- jQuery("#check1").click(function() {
+ jQuery( "#check1" ).click( function() {
assert.ok( true, "click event handler for checkbox gets fired twice, see #815" );
- }).click();
+ } ).click();
counter = 0;
- jQuery("#firstp")[0].onclick = function() {
+ jQuery( "#firstp" )[ 0 ].onclick = function() {
counter++;
};
- jQuery("#firstp").click();
+ jQuery( "#firstp" ).click();
assert.equal( counter, 1, "Check that click, triggers onclick event handler also" );
clickCounter = 0;
- jQuery("#simon1")[0].onclick = function() {
+ jQuery( "#simon1" )[ 0 ].onclick = function() {
clickCounter++;
};
- jQuery("#simon1").click();
+ jQuery( "#simon1" ).click();
assert.equal( clickCounter, 1, "Check that click, triggers onclick event handler on an a tag also" );
// test that special handlers do not blow up with VML elements (#7071)
- jQuery("
").appendTo("head");
- jQuery("
").appendTo("#form");
- jQuery("#oval").click().keydown();
- });
+ jQuery( "
" ).appendTo( "head" );
+ jQuery( "
" ).appendTo( "#form" );
+ jQuery( "#oval" ).click().keydown();
+ } );
}
-QUnit.test("trigger() bubbling", function( assert ) {
- assert.expect(18);
+QUnit.test( "trigger() bubbling", function( assert ) {
+ assert.expect( 18 );
var win = 0, doc = 0, html = 0, body = 0, main = 0, ap = 0;
- jQuery(window).on("click", function(){ win++; });
- jQuery(document).on("click", function( e ){ if ( e.target !== document) { doc++; } });
- jQuery("html").on("click", function(){ html++; });
- jQuery("body").on("click", function(){ body++; });
- jQuery("#qunit-fixture").on("click", function(){ main++; });
- jQuery("#ap").on("click", function(){ ap++; return false; });
+ jQuery( window ).on( "click", function() { win++; } );
+ jQuery( document ).on( "click", function( e ) { if ( e.target !== document ) { doc++; } } );
+ jQuery( "html" ).on( "click", function() { html++; } );
+ jQuery( "body" ).on( "click", function() { body++; } );
+ jQuery( "#qunit-fixture" ).on( "click", function() { main++; } );
+ jQuery( "#ap" ).on( "click", function() { ap++; return false; } );
- jQuery("html").trigger("click");
+ jQuery( "html" ).trigger( "click" );
assert.equal( win, 1, "HTML bubble" );
assert.equal( doc, 1, "HTML bubble" );
assert.equal( html, 1, "HTML bubble" );
- jQuery("body").trigger("click");
+ jQuery( "body" ).trigger( "click" );
assert.equal( win, 2, "Body bubble" );
assert.equal( doc, 2, "Body bubble" );
assert.equal( html, 2, "Body bubble" );
assert.equal( body, 1, "Body bubble" );
- jQuery("#qunit-fixture").trigger("click");
+ jQuery( "#qunit-fixture" ).trigger( "click" );
assert.equal( win, 3, "Main bubble" );
assert.equal( doc, 3, "Main bubble" );
assert.equal( html, 3, "Main bubble" );
assert.equal( body, 2, "Main bubble" );
assert.equal( main, 1, "Main bubble" );
- jQuery("#ap").trigger("click");
+ jQuery( "#ap" ).trigger( "click" );
assert.equal( doc, 3, "ap bubble" );
assert.equal( html, 3, "ap bubble" );
assert.equal( body, 2, "ap bubble" );
assert.equal( main, 1, "ap bubble" );
assert.equal( ap, 1, "ap bubble" );
- jQuery( document ).trigger("click");
+ jQuery( document ).trigger( "click" );
assert.equal( win, 4, "doc bubble" );
// manually clean up events from elements outside the fixture
- jQuery(window).off("click");
- jQuery(document).off("click");
- jQuery("html, body, #qunit-fixture").off("click");
-});
+ jQuery( window ).off( "click" );
+ jQuery( document ).off( "click" );
+ jQuery( "html, body, #qunit-fixture" ).off( "click" );
+} );
-QUnit.test("trigger(type, [data], [fn])", function( assert ) {
- assert.expect(16);
+QUnit.test( "trigger(type, [data], [fn])", function( assert ) {
+ assert.expect( 16 );
var $elem, pass, form, elem2,
- handler = function(event, a, b, c) {
+ handler = function( event, a, b, c ) {
assert.equal( event.type, "click", "check passed data" );
assert.equal( a, 1, "check passed data" );
assert.equal( b, "2", "check passed data" );
@@ -1001,92 +1007,91 @@ QUnit.test("trigger(type, [data], [fn])", function( assert ) {
return "test";
};
- $elem = jQuery("#firstp");
+ $elem = jQuery( "#firstp" );
// Simulate a "native" click
- $elem[0].click = function(){
+ $elem[ 0 ].click = function() {
assert.ok( true, "Native call was triggered" );
};
-
- jQuery( document ).on("mouseenter", "#firstp", function(){
+ jQuery( document ).on( "mouseenter", "#firstp", function() {
assert.ok( true, "Trigger mouseenter bound by on" );
- });
+ } );
- jQuery( document ).on("mouseleave", "#firstp", function(){
+ jQuery( document ).on( "mouseleave", "#firstp", function() {
assert.ok( true, "Trigger mouseleave bound by on" );
- });
+ } );
- $elem.trigger("mouseenter");
+ $elem.trigger( "mouseenter" );
- $elem.trigger("mouseleave");
+ $elem.trigger( "mouseleave" );
- jQuery( document ).off( "mouseenter mouseleave", "#firstp");
+ jQuery( document ).off( "mouseenter mouseleave", "#firstp" );
// Triggers handlers and native
// Trigger 5
- $elem.on("click", handler).trigger("click", [1, "2", "abc"]);
+ $elem.on( "click", handler ).trigger( "click", [ 1, "2", "abc" ] );
// Simulate a "native" click
- $elem[0].click = function(){
+ $elem[ 0 ].click = function() {
assert.ok( false, "Native call was triggered" );
};
// Trigger only the handlers (no native)
// Triggers 5
- assert.equal( $elem.triggerHandler("click", [1, "2", "abc"]), "test", "Verify handler response" );
+ assert.equal( $elem.triggerHandler( "click", [ 1, "2", "abc" ] ), "test", "Verify handler response" );
pass = true;
try {
- elem2 = jQuery("#form input").eq(0);
- elem2.get(0).style.display = "none";
- elem2.trigger("focus");
- } catch( e ) {
+ elem2 = jQuery( "#form input" ).eq( 0 );
+ elem2.get( 0 ).style.display = "none";
+ elem2.trigger( "focus" );
+ } catch ( e ) {
pass = false;
}
assert.ok( pass, "Trigger focus on hidden element" );
pass = true;
try {
- jQuery("#qunit-fixture table").eq(0).on("test:test", function(){}).trigger("test:test");
+ jQuery( "#qunit-fixture table" ).eq( 0 ).on( "test:test", function() {} ).trigger( "test:test" );
} catch ( e ) {
pass = false;
}
assert.ok( pass, "Trigger on a table with a colon in the even type, see #3533" );
- form = jQuery("
").appendTo("body");
+ form = jQuery( "
" ).appendTo( "body" );
// Make sure it can be prevented locally
- form.on( "submit", function(){
+ form.on( "submit", function() {
assert.ok( true, "Local `on` still works." );
return false;
- });
+ } );
// Trigger 1
- form.trigger("submit");
+ form.trigger( "submit" );
- form.off("submit");
+ form.off( "submit" );
- jQuery(document).on( "submit", function(){
+ jQuery( document ).on( "submit", function() {
assert.ok( true, "Make sure bubble works up to document." );
return false;
- });
+ } );
// Trigger 1
- form.trigger("submit");
+ form.trigger( "submit" );
- jQuery(document).off("submit");
+ jQuery( document ).off( "submit" );
form.remove();
-});
+} );
QUnit.test( "submit event bubbles on copied forms (#11649)", function( assert ) {
assert.expect( 3 );
var $formByClone, $formByHTML,
- $testForm = jQuery("#testForm"),
- $fixture = jQuery("#qunit-fixture"),
- $wrapperDiv = jQuery("
").appendTo( $fixture );
+ $testForm = jQuery( "#testForm" ),
+ $fixture = jQuery( "#qunit-fixture" ),
+ $wrapperDiv = jQuery( "
" ).appendTo( $fixture );
function noSubmit( e ) {
e.preventDefault();
@@ -1100,29 +1105,29 @@ QUnit.test( "submit event bubbles on copied forms (#11649)", function( assert )
$fixture.on( "submit", "form", delegatedSubmit );
// Trigger form submission to introduce the _submit_attached property
- $testForm.on( "submit", noSubmit ).find("input[name=sub1]").trigger("click");
+ $testForm.on( "submit", noSubmit ).find( "input[name=sub1]" ).trigger( "click" );
// Copy the form via .clone() and .html()
- $formByClone = $testForm.clone( true, true ).removeAttr("id");
- $formByHTML = jQuery( jQuery.parseHTML($fixture.html()) ).filter("#testForm").removeAttr("id");
+ $formByClone = $testForm.clone( true, true ).removeAttr( "id" );
+ $formByHTML = jQuery( jQuery.parseHTML( $fixture.html() ) ).filter( "#testForm" ).removeAttr( "id" );
$wrapperDiv.append( $formByClone, $formByHTML );
// Check submit bubbling on the copied forms
- $wrapperDiv.find("form").on( "submit", noSubmit ).find("input[name=sub1]").trigger("click");
+ $wrapperDiv.find( "form" ).on( "submit", noSubmit ).find( "input[name=sub1]" ).trigger( "click" );
// Clean up
$wrapperDiv.remove();
$fixture.off( "submit", "form", delegatedSubmit );
$testForm.off( "submit", noSubmit );
-});
+} );
-QUnit.test( "change event bubbles on copied forms (#11796)", function( assert ){
+QUnit.test( "change event bubbles on copied forms (#11796)", function( assert ) {
assert.expect( 3 );
var $formByClone, $formByHTML,
- $form = jQuery("#form"),
- $fixture = jQuery("#qunit-fixture"),
- $wrapperDiv = jQuery("
").appendTo( $fixture );
+ $form = jQuery( "#form" ),
+ $fixture = jQuery( "#qunit-fixture" ),
+ $wrapperDiv = jQuery( "
" ).appendTo( $fixture );
function delegatedChange() {
assert.ok( true, "Make sure change event bubbles up." );
@@ -1133,31 +1138,31 @@ QUnit.test( "change event bubbles on copied forms (#11796)", function( assert ){
$fixture.on( "change", "form", delegatedChange );
// Trigger change event to introduce the _change_attached property
- $form.find("select[name=select1]").val("1").trigger("change");
+ $form.find( "select[name=select1]" ).val( "1" ).trigger( "change" );
// Copy the form via .clone() and .html()
- $formByClone = $form.clone( true, true ).removeAttr("id");
- $formByHTML = jQuery( jQuery.parseHTML($fixture.html()) ).filter("#form").removeAttr("id");
+ $formByClone = $form.clone( true, true ).removeAttr( "id" );
+ $formByHTML = jQuery( jQuery.parseHTML( $fixture.html() ) ).filter( "#form" ).removeAttr( "id" );
$wrapperDiv.append( $formByClone, $formByHTML );
// Check change bubbling on the copied forms
- $wrapperDiv.find("form select[name=select1]").val("2").trigger("change");
+ $wrapperDiv.find( "form select[name=select1]" ).val( "2" ).trigger( "change" );
// Clean up
$wrapperDiv.remove();
$fixture.off( "change", "form", delegatedChange );
-});
+} );
-QUnit.test("trigger(eventObject, [data], [fn])", function( assert ) {
- assert.expect(28);
+QUnit.test( "trigger(eventObject, [data], [fn])", function( assert ) {
+ assert.expect( 28 );
var event,
- $parent = jQuery("
").appendTo("body"),
- $child = jQuery("
foo
").appendTo( $parent );
+ $parent = jQuery( "
" ).appendTo( "body" ),
+ $child = jQuery( "
foo
" ).appendTo( $parent );
$parent.get( 0 ).style.display = "none";
- event = jQuery.Event("noNew");
+ event = jQuery.Event( "noNew" );
assert.ok( event !== window, "Instantiate jQuery.Event without the 'new' keyword" );
assert.equal( event.type, "noNew", "Verify its type" );
@@ -1170,40 +1175,41 @@ QUnit.test("trigger(eventObject, [data], [fn])", function( assert ) {
event.stopPropagation();
assert.equal( event.isPropagationStopped(), true, "Verify isPropagationStopped" );
- event.isPropagationStopped = function(){ return false; };
+ event.isPropagationStopped = function() { return false; };
event.stopImmediatePropagation();
assert.equal( event.isPropagationStopped(), true, "Verify isPropagationStopped" );
assert.equal( event.isImmediatePropagationStopped(), true, "Verify isPropagationStopped" );
- $parent.on("foo",function( e ) {
+ $parent.on( "foo", function( e ) {
+
// Tries bubbling
assert.equal( e.type, "foo", "Verify event type when passed passing an event object" );
assert.equal( e.target.id, "child", "Verify event.target when passed passing an event object" );
assert.equal( e.currentTarget.id, "par", "Verify event.currentTarget when passed passing an event object" );
assert.equal( e.secret, "boo!", "Verify event object's custom attribute when passed passing an event object" );
- });
+ } );
// test with an event object
- event = new jQuery.Event("foo");
+ event = new jQuery.Event( "foo" );
event.secret = "boo!";
- $child.trigger(event);
+ $child.trigger( event );
// test with a literal object
- $child.trigger({"type": "foo", "secret": "boo!"});
+ $child.trigger( { "type": "foo", "secret": "boo!" } );
$parent.off();
- function error(){
- assert.ok( false, "This assertion shouldn't be reached");
+ function error() {
+ assert.ok( false, "This assertion shouldn't be reached" );
}
- $parent.on("foo", error );
+ $parent.on( "foo", error );
- $child.on("foo",function(e, a, b, c ){
- assert.equal( arguments.length, 4, "Check arguments length");
- assert.equal( a, 1, "Check first custom argument");
- assert.equal( b, 2, "Check second custom argument");
- assert.equal( c, 3, "Check third custom argument");
+ $child.on( "foo", function( e, a, b, c ) {
+ assert.equal( arguments.length, 4, "Check arguments length" );
+ assert.equal( a, 1, "Check first custom argument" );
+ assert.equal( b, 2, "Check second custom argument" );
+ assert.equal( c, 3, "Check third custom argument" );
assert.equal( e.isDefaultPrevented(), false, "Verify isDefaultPrevented" );
assert.equal( e.isPropagationStopped(), false, "Verify isPropagationStopped" );
@@ -1213,18 +1219,18 @@ QUnit.test("trigger(eventObject, [data], [fn])", function( assert ) {
e.stopImmediatePropagation();
return "result";
- });
+ } );
// We should add this back in when we want to test the order
// in which event handlers are iterated.
//$child.on("foo", error );
- event = new jQuery.Event("foo");
- $child.trigger( event, [1,2,3] ).off();
- assert.equal( event.result, "result", "Check event.result attribute");
+ event = new jQuery.Event( "foo" );
+ $child.trigger( event, [ 1,2,3 ] ).off();
+ assert.equal( event.result, "result", "Check event.result attribute" );
// Will error if it bubbles
- $child.triggerHandler("foo");
+ $child.triggerHandler( "foo" );
$child.off();
$parent.off().remove();
@@ -1235,53 +1241,53 @@ QUnit.test("trigger(eventObject, [data], [fn])", function( assert ) {
assert.equal( event.type, "zowie", "Verify its type" );
assert.equal( event.isPropagationStopped(), false, "propagation not stopped" );
assert.equal( event.isDefaultPrevented(), false, "default not prevented" );
-});
+} );
-QUnit.test(".trigger() bubbling on disconnected elements (#10489)", function( assert ) {
- assert.expect(2);
+QUnit.test( ".trigger() bubbling on disconnected elements (#10489)", function( assert ) {
+ assert.expect( 2 );
- jQuery( window ).on( "click", function(){
+ jQuery( window ).on( "click", function() {
assert.ok( false, "click fired on window" );
- });
+ } );
jQuery( "
" )
.on( "click", function() {
assert.ok( true, "click fired on div" );
- })
+ } )
.find( "p" )
.on( "click", function() {
assert.ok( true, "click fired on p" );
- })
- .trigger("click")
+ } )
+ .trigger( "click" )
.off( "click" )
.end()
.off( "click" )
.remove();
jQuery( window ).off( "click" );
-});
+} );
-QUnit.test(".trigger() doesn't bubble load event (#10717)", function( assert ) {
- assert.expect(1);
+QUnit.test( ".trigger() doesn't bubble load event (#10717)", function( assert ) {
+ assert.expect( 1 );
- jQuery( window ).on( "load", function(){
+ jQuery( window ).on( "load", function() {
assert.ok( false, "load fired on window" );
- });
+ } );
// It's not an image, but as long as it fires load...
- jQuery("
")
+ jQuery( "
" )
.appendTo( "body" )
.on( "load", function() {
assert.ok( true, "load fired on img" );
- })
+ } )
.trigger( "load" )
.remove();
jQuery( window ).off( "load" );
-});
+} );
-QUnit.test("Delegated events in SVG (#10791; #13180)", function( assert ) {
- assert.expect(2);
+QUnit.test( "Delegated events in SVG (#10791; #13180)", function( assert ) {
+ assert.expect( 2 );
var useElem, e,
svg = jQuery(
@@ -1293,32 +1299,32 @@ QUnit.test("Delegated events in SVG (#10791; #13180)", function( assert ) {
""
);
- jQuery("#qunit-fixture")
+ jQuery( "#qunit-fixture" )
.append( svg )
.on( "click", "#svg-by-id", function() {
assert.ok( true, "delegated id selector" );
- })
+ } )
.on( "click", "[class~='svg-by-class']", function() {
assert.ok( true, "delegated class selector" );
- })
+ } )
.find( "#svg-by-id, [class~='svg-by-class']" )
- .trigger("click")
+ .trigger( "click" )
.end();
// Fire a native click on an SVGElementInstance (the instance tree of an SVG
)
// to confirm that it doesn't break our event delegation handling (#13180)
- useElem = svg.find("#use")[0];
+ useElem = svg.find( "#use" )[ 0 ];
if ( document.createEvent && useElem && useElem.instanceRoot ) {
- e = document.createEvent("MouseEvents");
+ e = document.createEvent( "MouseEvents" );
e.initEvent( "click", true, true );
useElem.instanceRoot.dispatchEvent( e );
}
- jQuery("#qunit-fixture").off("click");
-});
+ jQuery( "#qunit-fixture" ).off( "click" );
+} );
-QUnit.test("Delegated events in forms (#10844; #11145; #8165; #11382, #11764)", function( assert ) {
- assert.expect(5);
+QUnit.test( "Delegated events in forms (#10844; #11145; #8165; #11382, #11764)", function( assert ) {
+ assert.expect( 5 );
// Alias names like "id" cause havoc
var form = jQuery(
@@ -1328,36 +1334,36 @@ QUnit.test("Delegated events in forms (#10844; #11145; #8165; #11382, #11764)",
)
.on( "submit", function( event ) {
event.preventDefault();
- })
- .appendTo("body");
+ } )
+ .appendTo( "body" );
- jQuery("body")
+ jQuery( "body" )
.on( "submit", "#myform", function() {
assert.ok( true, "delegated id selector with aliased id" );
- })
- .find("#myform")
- .trigger("submit")
+ } )
+ .find( "#myform" )
+ .trigger( "submit" )
.end()
- .off("submit");
+ .off( "submit" );
- form.append("Zing 
" ).appendTo("#qunit-fixture");
- } catch (err) {
- jQuery["_check9521"](true);
- }
-});
-QUnit.test("isXMLDoc - XML", function( assert ) {
- assert.expect(3);
+ // This throws an error because it's processed like an id
+ jQuery( "#
" );
- window.setTimeout(function() {
+ window.setTimeout( function() {
QUnit.start();
assert.equal( window.parseHTMLError, false, "onerror eventhandler has not been called." );
- }, 2000);
- });
+ }, 2000 );
+ } );
}
-QUnit.test("jQuery.parseJSON", function( assert ) {
+QUnit.test( "jQuery.parseJSON", function( assert ) {
assert.expect( 20 );
assert.strictEqual( jQuery.parseJSON( null ), null, "primitive null" );
- assert.strictEqual( jQuery.parseJSON("0.88"), 0.88, "Number" );
+ assert.strictEqual( jQuery.parseJSON( "0.88" ), 0.88, "Number" );
assert.strictEqual(
- jQuery.parseJSON("\" \\\" \\\\ \\/ \\b \\f \\n \\r \\t \\u007E \\u263a \""),
+ jQuery.parseJSON( "\" \\\" \\\\ \\/ \\b \\f \\n \\r \\t \\u007E \\u263a \"" ),
" \" \\ / \b \f \n \r \t ~ \u263A ",
"String escapes"
);
- assert.deepEqual( jQuery.parseJSON("{}"), {}, "Empty object" );
- assert.deepEqual( jQuery.parseJSON("{\"test\":1}"), { "test": 1 }, "Plain object" );
- assert.deepEqual( jQuery.parseJSON("[0]"), [ 0 ], "Simple array" );
+ assert.deepEqual( jQuery.parseJSON( "{}" ), {}, "Empty object" );
+ assert.deepEqual( jQuery.parseJSON( "{\"test\":1}" ), { "test": 1 }, "Plain object" );
+ assert.deepEqual( jQuery.parseJSON( "[0]" ), [ 0 ], "Simple array" );
assert.deepEqual(
- jQuery.parseJSON("[ \"string\", -4.2, 2.7180e0, 3.14E-1, {}, [], true, false, null ]"),
+ jQuery.parseJSON( "[ \"string\", -4.2, 2.7180e0, 3.14E-1, {}, [], true, false, null ]" ),
[ "string", -4.2, 2.718, 0.314, {}, [], true, false, null ],
"Array of all data types"
);
assert.deepEqual(
jQuery.parseJSON( "{ \"string\": \"\", \"number\": 4.2e+1, \"object\": {}," +
- "\"array\": [[]], \"boolean\": [ true, false ], \"null\": null }"),
- { string: "", number: 42, object: {}, array: [[]], "boolean": [ true, false ], "null": null },
+ "\"array\": [[]], \"boolean\": [ true, false ], \"null\": null }" ),
+ { string: "", number: 42, object: {}, array: [ [] ], "boolean": [ true, false ], "null": null },
"Dictionary of all data types"
);
- assert.deepEqual( jQuery.parseJSON("\n{\"test\":1}\t"), { "test": 1 },
+ assert.deepEqual( jQuery.parseJSON( "\n{\"test\":1}\t" ), { "test": 1 },
"Leading and trailing whitespace are ignored" );
- assert.throws(function() {
+ assert.throws( function() {
jQuery.parseJSON();
}, null, "Undefined raises an error" );
- assert.throws(function() {
+ assert.throws( function() {
jQuery.parseJSON( "" );
}, null, "Empty string raises an error" );
- assert.throws(function() {
- jQuery.parseJSON("''");
+ assert.throws( function() {
+ jQuery.parseJSON( "''" );
}, null, "Single-quoted string raises an error" );
/*
@@ -1450,38 +1456,38 @@ QUnit.test("jQuery.parseJSON", function( assert ) {
}, null, "Number with no integer component raises an error" );
*/
- assert.throws(function() {
- var result = jQuery.parseJSON("0101");
+ assert.throws( function() {
+ var result = jQuery.parseJSON( "0101" );
// Support: IE9+
// Ensure base-10 interpretation on browsers that erroneously accept leading-zero numbers
if ( result === 101 ) {
- throw new Error("close enough");
+ throw new Error( "close enough" );
}
}, null, "Leading-zero number raises an error or is parsed as decimal" );
- assert.throws(function() {
- jQuery.parseJSON("{a:1}");
+ assert.throws( function() {
+ jQuery.parseJSON( "{a:1}" );
}, null, "Unquoted property raises an error" );
- assert.throws(function() {
- jQuery.parseJSON("{'a':1}");
+ assert.throws( function() {
+ jQuery.parseJSON( "{'a':1}" );
}, null, "Single-quoted property raises an error" );
- assert.throws(function() {
- jQuery.parseJSON("[,]");
+ assert.throws( function() {
+ jQuery.parseJSON( "[,]" );
}, null, "Array element elision raises an error" );
- assert.throws(function() {
- jQuery.parseJSON("{},[]");
+ assert.throws( function() {
+ jQuery.parseJSON( "{},[]" );
}, null, "Comma expression raises an error" );
- assert.throws(function() {
- jQuery.parseJSON("[]\n,{}");
+ assert.throws( function() {
+ jQuery.parseJSON( "[]\n,{}" );
}, null, "Newline-containing comma expression raises an error" );
- assert.throws(function() {
- jQuery.parseJSON("\"\"\n\"\"");
+ assert.throws( function() {
+ jQuery.parseJSON( "\"\"\n\"\"" );
}, null, "Automatic semicolon insertion raises an error" );
- assert.strictEqual( jQuery.parseJSON([ 0 ]), 0, "Input cast to string" );
-});
+ assert.strictEqual( jQuery.parseJSON( [ 0 ] ), 0, "Input cast to string" );
+} );
-QUnit.test("jQuery.parseXML", function( assert ){
+QUnit.test( "jQuery.parseXML", function( assert ) {
assert.expect( 8 );
var xml, tmp;
@@ -1492,13 +1498,13 @@ QUnit.test("jQuery.parseXML", function( assert ){
tmp = tmp.getElementsByTagName( "b" )[ 0 ];
assert.ok( !!tmp, " present in document" );
assert.strictEqual( tmp.childNodes[ 0 ].nodeValue, "well-formed", " text is as expected" );
- } catch (e) {
+ } catch ( e ) {
assert.strictEqual( e, undefined, "unexpected error" );
}
try {
xml = jQuery.parseXML( "
").appendTo("body");
- assert.equal( $img.attr("width"), "215", "Retrieve width attribute an an element with display:none." );
- assert.equal( $img.attr("height"), "53", "Retrieve height attribute an an element with display:none." );
+ $img = jQuery( "