2013-04-09 15:45:09 +00:00
|
|
|
(function() {
|
|
|
|
|
|
|
|
|
|
if ( !jQuery.fn.width ) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2012-06-05 19:29:46 +00:00
|
|
|
|
2011-01-09 21:58:47 +00:00
|
|
|
module("dimensions", { teardown: moduleTeardown });
|
2008-04-29 03:26:06 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
function pass( val ) {
|
2010-01-24 01:49:59 +00:00
|
|
|
return val;
|
2013-04-09 15:45:09 +00:00
|
|
|
}
|
2010-01-24 01:49:59 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
function fn( val ) {
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
return function() {
|
|
|
|
|
return val;
|
|
|
|
|
};
|
2013-04-09 15:45:09 +00:00
|
|
|
}
|
2010-01-24 01:49:59 +00:00
|
|
|
|
2012-05-29 16:40:13 +00:00
|
|
|
/*
|
|
|
|
|
======== local reference =======
|
|
|
|
|
pass and fn can be used to test passing functions to setters
|
|
|
|
|
See testWidth below for an example
|
|
|
|
|
|
|
|
|
|
pass( value );
|
|
|
|
|
This function returns whatever value is passed in
|
|
|
|
|
|
|
|
|
|
fn( value );
|
|
|
|
|
Returns a function that returns the value
|
|
|
|
|
*/
|
|
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
function testWidth( val ) {
|
2012-05-14 18:12:14 +00:00
|
|
|
expect(9);
|
2013-04-09 15:45:09 +00:00
|
|
|
var $div, blah;
|
2009-03-22 23:25:58 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
$div = jQuery("#nothiddendiv");
|
2010-01-24 01:49:59 +00:00
|
|
|
$div.width( val(30) );
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.width(), 30, "Test set to 30 correctly");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.hide();
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.width(), 30, "Test hidden div");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.show();
|
2012-04-27 15:22:01 +00:00
|
|
|
$div.width( val(-1) ); // handle negative numbers by setting to 0 #11604
|
|
|
|
|
equal($div.width(), 0, "Test negative width normalized to 0");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.css("padding", "20px");
|
2012-04-27 15:22:01 +00:00
|
|
|
equal($div.width(), 0, "Test padding specified with pixels");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.css("border", "2px solid #fff");
|
2012-04-27 15:22:01 +00:00
|
|
|
equal($div.width(), 0, "Test border specified with pixels");
|
2009-03-22 23:25:58 +00:00
|
|
|
|
2012-07-05 19:52:13 +00:00
|
|
|
$div.css({ "display": "", "border": "", "padding": "" });
|
2009-03-22 23:25:58 +00:00
|
|
|
|
2012-07-05 19:52:13 +00:00
|
|
|
jQuery("#nothiddendivchild").css({ "width": 20, "padding": "3px", "border": "2px solid #fff" });
|
2011-11-06 20:27:42 +00:00
|
|
|
equal(jQuery("#nothiddendivchild").width(), 20, "Test child width with border and padding");
|
2012-07-05 19:52:13 +00:00
|
|
|
jQuery("#nothiddendiv, #nothiddendivchild").css({ "border": "", "padding": "", "width": "" });
|
2009-12-10 05:58:29 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
blah = jQuery("blah");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( blah.width( val(10) ), blah, "Make sure that setting a width on an empty set returns the set." );
|
|
|
|
|
equal( blah.width(), null, "Make sure 'null' is returned on an empty set");
|
2011-01-09 21:58:47 +00:00
|
|
|
|
2012-05-14 18:12:14 +00:00
|
|
|
equal( jQuery(window).width(), document.documentElement.clientWidth, "Window width is equal to width reported by window/document." );
|
|
|
|
|
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
QUnit.expectJqData( $div[0], "olddisplay" );
|
2013-04-09 15:45:09 +00:00
|
|
|
}
|
2010-01-24 01:49:59 +00:00
|
|
|
|
|
|
|
|
test("width()", function() {
|
|
|
|
|
testWidth( pass );
|
2009-03-22 23:25:58 +00:00
|
|
|
});
|
|
|
|
|
|
2011-12-06 20:25:38 +00:00
|
|
|
test("width(Function)", function() {
|
2010-01-24 01:49:59 +00:00
|
|
|
testWidth( fn );
|
|
|
|
|
});
|
|
|
|
|
|
2011-12-06 20:25:38 +00:00
|
|
|
test("width(Function(args))", function() {
|
2010-01-24 01:49:59 +00:00
|
|
|
expect( 2 );
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2010-01-24 01:49:59 +00:00
|
|
|
var $div = jQuery("#nothiddendiv");
|
|
|
|
|
$div.width( 30 ).width(function(i, width) {
|
2013-02-27 20:44:34 +00:00
|
|
|
equal( width, 30, "Make sure previous value is correct." );
|
2010-01-24 01:49:59 +00:00
|
|
|
return width + 1;
|
|
|
|
|
});
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( $div.width(), 31, "Make sure value was modified correctly." );
|
2010-01-24 01:49:59 +00:00
|
|
|
});
|
|
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
function testHeight( val ) {
|
2012-05-14 18:12:14 +00:00
|
|
|
expect(9);
|
2009-03-22 23:25:58 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
var $div, blah;
|
|
|
|
|
|
|
|
|
|
$div = jQuery("#nothiddendiv");
|
2010-01-24 01:49:59 +00:00
|
|
|
$div.height( val(30) );
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.height(), 30, "Test set to 30 correctly");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.hide();
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.height(), 30, "Test hidden div");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.show();
|
2012-04-27 15:22:01 +00:00
|
|
|
$div.height( val(-1) ); // handle negative numbers by setting to 0 #11604
|
|
|
|
|
equal($div.height(), 0, "Test negative height normalized to 0");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.css("padding", "20px");
|
2012-04-27 15:22:01 +00:00
|
|
|
equal($div.height(), 0, "Test padding specified with pixels");
|
2009-03-22 23:25:58 +00:00
|
|
|
$div.css("border", "2px solid #fff");
|
2012-04-27 15:22:01 +00:00
|
|
|
equal($div.height(), 0, "Test border specified with pixels");
|
2009-03-22 23:25:58 +00:00
|
|
|
|
2012-07-05 19:52:13 +00:00
|
|
|
$div.css({ "display": "", "border": "", "padding": "", "height": "1px" });
|
2009-12-10 05:58:29 +00:00
|
|
|
|
2012-07-05 19:52:13 +00:00
|
|
|
jQuery("#nothiddendivchild").css({ "height": 20, "padding": "3px", "border": "2px solid #fff" });
|
2011-11-06 20:27:42 +00:00
|
|
|
equal(jQuery("#nothiddendivchild").height(), 20, "Test child height with border and padding");
|
2012-07-05 19:52:13 +00:00
|
|
|
jQuery("#nothiddendiv, #nothiddendivchild").css({ "border": "", "padding": "", "height": "" });
|
2010-09-01 16:05:35 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
blah = jQuery("blah");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( blah.height( val(10) ), blah, "Make sure that setting a height on an empty set returns the set." );
|
|
|
|
|
equal( blah.height(), null, "Make sure 'null' is returned on an empty set");
|
2011-01-09 21:58:47 +00:00
|
|
|
|
2012-05-14 18:12:14 +00:00
|
|
|
equal( jQuery(window).height(), document.documentElement.clientHeight, "Window width is equal to width reported by window/document." );
|
|
|
|
|
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
QUnit.expectJqData( $div[0], "olddisplay" );
|
2013-04-09 15:45:09 +00:00
|
|
|
}
|
2010-01-24 01:49:59 +00:00
|
|
|
|
|
|
|
|
test("height()", function() {
|
|
|
|
|
testHeight( pass );
|
|
|
|
|
});
|
|
|
|
|
|
2011-12-06 20:25:38 +00:00
|
|
|
test("height(Function)", function() {
|
2010-01-24 01:49:59 +00:00
|
|
|
testHeight( fn );
|
|
|
|
|
});
|
|
|
|
|
|
2011-12-06 20:25:38 +00:00
|
|
|
test("height(Function(args))", function() {
|
2010-01-24 01:49:59 +00:00
|
|
|
expect( 2 );
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2010-01-24 01:49:59 +00:00
|
|
|
var $div = jQuery("#nothiddendiv");
|
|
|
|
|
$div.height( 30 ).height(function(i, height) {
|
2013-02-27 20:44:34 +00:00
|
|
|
equal( height, 30, "Make sure previous value is correct." );
|
2010-01-24 01:49:59 +00:00
|
|
|
return height + 1;
|
|
|
|
|
});
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( $div.height(), 31, "Make sure value was modified correctly." );
|
2009-03-22 23:25:58 +00:00
|
|
|
});
|
|
|
|
|
|
2008-04-29 03:26:06 +00:00
|
|
|
test("innerWidth()", function() {
|
2012-05-21 17:44:19 +00:00
|
|
|
expect(6);
|
2011-05-25 23:49:50 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
var $div, div,
|
|
|
|
|
winWidth = jQuery( window ).width(),
|
2011-09-30 21:50:07 +00:00
|
|
|
docWidth = jQuery( document ).width();
|
2011-05-25 23:49:50 +00:00
|
|
|
|
2012-05-21 17:44:19 +00:00
|
|
|
equal(jQuery(window).innerWidth(), winWidth, "Test on window");
|
|
|
|
|
equal(jQuery(document).innerWidth(), docWidth, "Test on document");
|
2008-04-29 03:26:06 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
$div = jQuery("#nothiddendiv");
|
2008-04-29 03:26:06 +00:00
|
|
|
// set styles
|
|
|
|
|
$div.css({
|
2012-07-05 19:52:13 +00:00
|
|
|
"margin": 10,
|
|
|
|
|
"border": "2px solid #fff",
|
|
|
|
|
"width": 30
|
2008-04-29 03:26:06 +00:00
|
|
|
});
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.innerWidth(), 30, "Test with margin and border");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("padding", "20px");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.innerWidth(), 70, "Test with margin, border and padding");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.hide();
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.innerWidth(), 70, "Test hidden div");
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2008-04-29 03:26:06 +00:00
|
|
|
// reset styles
|
2012-07-05 19:52:13 +00:00
|
|
|
$div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
|
2010-11-10 04:29:26 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
div = jQuery( "<div>" );
|
2010-11-10 04:29:26 +00:00
|
|
|
|
|
|
|
|
// Temporarily require 0 for backwards compat - should be auto
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( div.innerWidth(), 0, "Make sure that disconnected nodes are handled." );
|
2011-01-09 21:58:47 +00:00
|
|
|
|
|
|
|
|
div.remove();
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
QUnit.expectJqData( $div[0], "olddisplay" );
|
2008-04-29 03:26:06 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test("innerHeight()", function() {
|
2012-05-21 17:44:19 +00:00
|
|
|
expect(6);
|
2011-05-25 23:49:50 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
var $div, div,
|
|
|
|
|
winHeight = jQuery( window ).height(),
|
2011-09-30 21:50:07 +00:00
|
|
|
docHeight = jQuery( document ).height();
|
|
|
|
|
|
2012-05-21 17:44:19 +00:00
|
|
|
equal(jQuery(window).innerHeight(), winHeight, "Test on window");
|
|
|
|
|
equal(jQuery(document).innerHeight(), docHeight, "Test on document");
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
$div = jQuery("#nothiddendiv");
|
2008-04-29 03:26:06 +00:00
|
|
|
// set styles
|
|
|
|
|
$div.css({
|
2012-07-05 19:52:13 +00:00
|
|
|
"margin": 10,
|
|
|
|
|
"border": "2px solid #fff",
|
|
|
|
|
"height": 30
|
2008-04-29 03:26:06 +00:00
|
|
|
});
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.innerHeight(), 30, "Test with margin and border");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("padding", "20px");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.innerHeight(), 70, "Test with margin, border and padding");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.hide();
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.innerHeight(), 70, "Test hidden div");
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2008-04-29 03:26:06 +00:00
|
|
|
// reset styles
|
2012-07-05 19:52:13 +00:00
|
|
|
$div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
|
2010-11-10 04:29:26 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
div = jQuery( "<div>" );
|
2010-11-10 04:29:26 +00:00
|
|
|
|
|
|
|
|
// Temporarily require 0 for backwards compat - should be auto
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( div.innerHeight(), 0, "Make sure that disconnected nodes are handled." );
|
2011-01-09 21:58:47 +00:00
|
|
|
|
|
|
|
|
div.remove();
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
QUnit.expectJqData( $div[0], "olddisplay" );
|
2008-04-29 03:26:06 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
test("outerWidth()", function() {
|
2011-05-25 23:49:50 +00:00
|
|
|
expect(11);
|
|
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
var $div, div,
|
|
|
|
|
winWidth = jQuery( window ).width(),
|
2011-09-30 21:50:07 +00:00
|
|
|
docWidth = jQuery( document ).width();
|
|
|
|
|
|
|
|
|
|
equal( jQuery( window ).outerWidth(), winWidth, "Test on window without margin option" );
|
|
|
|
|
equal( jQuery( window ).outerWidth( true ), winWidth, "Test on window with margin option" );
|
|
|
|
|
equal( jQuery( document ).outerWidth(), docWidth, "Test on document without margin option" );
|
|
|
|
|
equal( jQuery( document ).outerWidth( true ), docWidth, "Test on document with margin option" );
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
$div = jQuery("#nothiddendiv");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("width", 30);
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerWidth(), 30, "Test with only width set");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("padding", "20px");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerWidth(), 70, "Test with padding");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("border", "2px solid #fff");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerWidth(), 74, "Test with padding and border");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("margin", "10px");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerWidth(), 74, "Test with padding, border and margin without margin option");
|
2008-05-13 18:56:56 +00:00
|
|
|
$div.css("position", "absolute");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerWidth(true), 94, "Test with padding, border and margin with margin option");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.hide();
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerWidth(true), 94, "Test hidden div with padding, border and margin with margin option");
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2008-04-29 03:26:06 +00:00
|
|
|
// reset styles
|
2012-07-05 19:52:13 +00:00
|
|
|
$div.css({ "position": "", "display": "", "border": "", "padding": "", "width": "", "height": "" });
|
2010-11-10 04:29:26 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
div = jQuery( "<div>" );
|
2010-11-10 04:29:26 +00:00
|
|
|
|
|
|
|
|
// Temporarily require 0 for backwards compat - should be auto
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( div.outerWidth(), 0, "Make sure that disconnected nodes are handled." );
|
2011-01-09 21:58:47 +00:00
|
|
|
|
|
|
|
|
div.remove();
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
QUnit.expectJqData( $div[0], "olddisplay" );
|
2008-04-29 03:26:06 +00:00
|
|
|
});
|
|
|
|
|
|
2012-04-06 12:39:59 +00:00
|
|
|
test("child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height() see #9441 #9300", function() {
|
|
|
|
|
expect(16);
|
2011-06-07 03:13:37 +00:00
|
|
|
|
2011-06-07 03:35:16 +00:00
|
|
|
// setup html
|
2012-07-05 19:52:13 +00:00
|
|
|
var $divNormal = jQuery("<div>").css({ "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" }),
|
2012-04-06 12:39:59 +00:00
|
|
|
$divChild = $divNormal.clone(),
|
|
|
|
|
$divUnconnected = $divNormal.clone(),
|
2011-06-07 03:35:16 +00:00
|
|
|
$divHiddenParent = jQuery("<div>").css( "display", "none" ).append( $divChild ).appendTo("body");
|
|
|
|
|
$divNormal.appendTo("body");
|
2011-06-07 03:13:37 +00:00
|
|
|
|
2011-06-07 03:35:16 +00:00
|
|
|
// tests that child div of a hidden div works the same as a normal div
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( $divChild.width(), $divNormal.width(), "child of a hidden element width() is wrong see #9441" );
|
|
|
|
|
equal( $divChild.innerWidth(), $divNormal.innerWidth(), "child of a hidden element innerWidth() is wrong see #9441" );
|
|
|
|
|
equal( $divChild.outerWidth(), $divNormal.outerWidth(), "child of a hidden element outerWidth() is wrong see #9441" );
|
|
|
|
|
equal( $divChild.outerWidth(true), $divNormal.outerWidth( true ), "child of a hidden element outerWidth( true ) is wrong see #9300" );
|
2011-06-07 03:35:16 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( $divChild.height(), $divNormal.height(), "child of a hidden element height() is wrong see #9441" );
|
|
|
|
|
equal( $divChild.innerHeight(), $divNormal.innerHeight(), "child of a hidden element innerHeight() is wrong see #9441" );
|
|
|
|
|
equal( $divChild.outerHeight(), $divNormal.outerHeight(), "child of a hidden element outerHeight() is wrong see #9441" );
|
|
|
|
|
equal( $divChild.outerHeight(true), $divNormal.outerHeight( true ), "child of a hidden element outerHeight( true ) is wrong see #9300" );
|
2011-06-07 03:13:37 +00:00
|
|
|
|
2012-04-06 12:39:59 +00:00
|
|
|
// tests that child div of an unconnected div works the same as a normal div
|
|
|
|
|
equal( $divUnconnected.width(), $divNormal.width(), "unconnected element width() is wrong see #9441" );
|
|
|
|
|
equal( $divUnconnected.innerWidth(), $divNormal.innerWidth(), "unconnected element innerWidth() is wrong see #9441" );
|
|
|
|
|
equal( $divUnconnected.outerWidth(), $divNormal.outerWidth(), "unconnected element outerWidth() is wrong see #9441" );
|
|
|
|
|
equal( $divUnconnected.outerWidth(true), $divNormal.outerWidth( true ), "unconnected element outerWidth( true ) is wrong see #9300" );
|
|
|
|
|
|
|
|
|
|
equal( $divUnconnected.height(), $divNormal.height(), "unconnected element height() is wrong see #9441" );
|
|
|
|
|
equal( $divUnconnected.innerHeight(), $divNormal.innerHeight(), "unconnected element innerHeight() is wrong see #9441" );
|
|
|
|
|
equal( $divUnconnected.outerHeight(), $divNormal.outerHeight(), "unconnected element outerHeight() is wrong see #9441" );
|
|
|
|
|
equal( $divUnconnected.outerHeight(true), $divNormal.outerHeight( true ), "unconnected element outerHeight( true ) is wrong see #9300" );
|
|
|
|
|
|
2011-06-07 03:35:16 +00:00
|
|
|
// teardown html
|
2011-06-07 03:13:37 +00:00
|
|
|
$divHiddenParent.remove();
|
|
|
|
|
$divNormal.remove();
|
|
|
|
|
});
|
|
|
|
|
|
2013-02-27 20:44:34 +00:00
|
|
|
test("getting dimensions shouldn't modify runtimeStyle see #9233", function() {
|
2011-10-28 14:53:42 +00:00
|
|
|
expect( 1 );
|
|
|
|
|
|
|
|
|
|
var $div = jQuery( "<div>" ).appendTo( "#qunit-fixture" ),
|
|
|
|
|
div = $div.get( 0 ),
|
|
|
|
|
runtimeStyle = div.runtimeStyle;
|
|
|
|
|
|
|
|
|
|
if ( runtimeStyle ) {
|
|
|
|
|
div.runtimeStyle.marginLeft = "12em";
|
|
|
|
|
div.runtimeStyle.left = "11em";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$div.outerWidth( true );
|
|
|
|
|
|
|
|
|
|
if ( runtimeStyle ) {
|
|
|
|
|
equal( div.runtimeStyle.left, "11em", "getting dimensions modifies runtimeStyle, see #9233" );
|
|
|
|
|
} else {
|
2013-02-27 20:44:34 +00:00
|
|
|
ok( true, "this browser doesn't support runtimeStyle, see #9233" );
|
2011-10-28 14:53:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$div.remove();
|
|
|
|
|
});
|
|
|
|
|
|
2012-08-29 12:50:56 +00:00
|
|
|
test( "table dimensions", 2, function() {
|
|
|
|
|
var table = jQuery("<table><colgroup><col/><col/></colgroup><tbody><tr><td></td><td>a</td></tr><tr><td></td><td>a</td></tr></tbody></table>").appendTo("#qunit-fixture"),
|
2013-02-19 04:52:29 +00:00
|
|
|
tdElem = table.find("td").first(),
|
|
|
|
|
colElem = table.find("col").first().width( 300 );
|
2012-06-07 15:08:31 +00:00
|
|
|
|
2012-07-05 19:52:13 +00:00
|
|
|
table.find("td").css({ "margin": 0, "padding": 0 });
|
2012-08-29 12:50:56 +00:00
|
|
|
|
|
|
|
|
equal( tdElem.width(), tdElem.width(), "width() doesn't alter dimension values of empty cells, see #11293" );
|
|
|
|
|
equal( colElem.width(), 300, "col elements have width(), see #12243" );
|
2012-06-07 15:08:31 +00:00
|
|
|
});
|
|
|
|
|
|
2012-04-06 12:39:59 +00:00
|
|
|
test("box-sizing:border-box child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height() see #10413", function() {
|
|
|
|
|
expect(16);
|
|
|
|
|
|
|
|
|
|
// setup html
|
2012-07-05 19:52:13 +00:00
|
|
|
var $divNormal = jQuery("<div>").css({ "boxSizing": "border-box", "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" }),
|
2012-04-06 12:39:59 +00:00
|
|
|
$divChild = $divNormal.clone(),
|
|
|
|
|
$divUnconnected = $divNormal.clone(),
|
|
|
|
|
$divHiddenParent = jQuery("<div>").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
|
|
|
|
|
equal( $divChild.width(), $divNormal.width(), "child of a hidden element width() is wrong see #10413" );
|
|
|
|
|
equal( $divChild.innerWidth(), $divNormal.innerWidth(), "child of a hidden element innerWidth() is wrong see #10413" );
|
|
|
|
|
equal( $divChild.outerWidth(), $divNormal.outerWidth(), "child of a hidden element outerWidth() is wrong see #10413" );
|
|
|
|
|
equal( $divChild.outerWidth(true), $divNormal.outerWidth( true ), "child of a hidden element outerWidth( true ) is wrong see #10413" );
|
|
|
|
|
|
|
|
|
|
equal( $divChild.height(), $divNormal.height(), "child of a hidden element height() is wrong see #10413" );
|
|
|
|
|
equal( $divChild.innerHeight(), $divNormal.innerHeight(), "child of a hidden element innerHeight() is wrong see #10413" );
|
|
|
|
|
equal( $divChild.outerHeight(), $divNormal.outerHeight(), "child of a hidden element outerHeight() is wrong see #10413" );
|
|
|
|
|
equal( $divChild.outerHeight(true), $divNormal.outerHeight( true ), "child of a hidden element outerHeight( true ) is wrong see #10413" );
|
|
|
|
|
|
|
|
|
|
// tests that child div of an unconnected div works the same as a normal div
|
|
|
|
|
equal( $divUnconnected.width(), $divNormal.width(), "unconnected element width() is wrong see #10413" );
|
|
|
|
|
equal( $divUnconnected.innerWidth(), $divNormal.innerWidth(), "unconnected element innerWidth() is wrong see #10413" );
|
|
|
|
|
equal( $divUnconnected.outerWidth(), $divNormal.outerWidth(), "unconnected element outerWidth() is wrong see #10413" );
|
|
|
|
|
equal( $divUnconnected.outerWidth(true), $divNormal.outerWidth( true ), "unconnected element outerWidth( true ) is wrong see #10413" );
|
|
|
|
|
|
|
|
|
|
equal( $divUnconnected.height(), $divNormal.height(), "unconnected element height() is wrong see #10413" );
|
|
|
|
|
equal( $divUnconnected.innerHeight(), $divNormal.innerHeight(), "unconnected element innerHeight() is wrong see #10413" );
|
|
|
|
|
equal( $divUnconnected.outerHeight(), $divNormal.outerHeight(), "unconnected element outerHeight() is wrong see #10413" );
|
|
|
|
|
equal( $divUnconnected.outerHeight(true), $divNormal.outerHeight( true ), "unconnected element outerHeight( true ) is wrong see #10413" );
|
|
|
|
|
|
|
|
|
|
// teardown html
|
|
|
|
|
$divHiddenParent.remove();
|
|
|
|
|
$divNormal.remove();
|
|
|
|
|
});
|
|
|
|
|
|
2008-04-29 03:26:06 +00:00
|
|
|
test("outerHeight()", function() {
|
2011-05-25 23:49:50 +00:00
|
|
|
expect(11);
|
|
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
var $div, div,
|
|
|
|
|
winHeight = jQuery( window ).height(),
|
2011-09-30 21:50:07 +00:00
|
|
|
docHeight = jQuery( document ).height();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
equal( jQuery( window ).outerHeight(), winHeight, "Test on window without margin option" );
|
|
|
|
|
equal( jQuery( window ).outerHeight( true ), winHeight, "Test on window with margin option" );
|
|
|
|
|
equal( jQuery( document ).outerHeight(), docHeight, "Test on document without margin option" );
|
|
|
|
|
equal( jQuery( document ).outerHeight( true ), docHeight, "Test on document with margin option" );
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
$div = jQuery("#nothiddendiv");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("height", 30);
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerHeight(), 30, "Test with only width set");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("padding", "20px");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerHeight(), 70, "Test with padding");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("border", "2px solid #fff");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerHeight(), 74, "Test with padding and border");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.css("margin", "10px");
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerHeight(), 74, "Test with padding, border and margin without margin option");
|
|
|
|
|
equal($div.outerHeight(true), 94, "Test with padding, border and margin with margin option");
|
2008-04-29 03:26:06 +00:00
|
|
|
$div.hide();
|
2011-11-06 20:27:42 +00:00
|
|
|
equal($div.outerHeight(true), 94, "Test hidden div with padding, border and margin with margin option");
|
2010-12-30 06:34:48 +00:00
|
|
|
|
2008-04-29 03:26:06 +00:00
|
|
|
// reset styles
|
2012-07-05 19:52:13 +00:00
|
|
|
$div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
|
2010-11-10 04:29:26 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
div = jQuery( "<div>" );
|
2010-11-10 04:29:26 +00:00
|
|
|
|
|
|
|
|
// Temporarily require 0 for backwards compat - should be auto
|
2011-11-06 20:27:42 +00:00
|
|
|
equal( div.outerHeight(), 0, "Make sure that disconnected nodes are handled." );
|
2011-01-09 21:58:47 +00:00
|
|
|
|
|
|
|
|
div.remove();
|
Implement expectation test instead of using _removeData. Close gh-997.
* Removed inline usage of QUnit.reset() because it is messing with the
expectation model as reset does .empty() which does a recursive cleanData
on everything in #qunit-fixture, so any expectJqData above .reset() would
fail negatively.
Instead of calling reset inline, either updated the following assertions to
take previous assertions' state into account, or broke the test() up into
2 tests at the point where it would call QUnit.reset.
* After introducing the new memory leak discovery a whole bunch of tests were
failing as they didn't clean up everything. However I didn't (yet) add
QUnit.expectJqData calls all over the place because in most if not all of
these cases it is valid data storage. For example in test "data()", there
will be an internal data key for "parsedAttrs". This particular test isn't
intending to test for memory leaks, so therefor I made the new discovery
system only push failures when the test contains at least 1 call to
QUnit.expectJqData.
When not, we'll assume that whatever data is being stored is acceptable
because the relevant elements still exist in the DOM anyway (QUnit.reset
will remove the elements and clean up the data automatically).
I did add a "Always check jQuery.data" mode in the test suite that will
trigger it everywhere. Maybe one day we'll include a call to everywhere,
but for now I'm keeping the status quo: Only consider data left in storage
to be a problem if the test says so ("opt-in").
* Had to move #fx-tests inside the fixture because ".remove()" test would
otherwise remove stuff permanently and cause random other tests to fail
as "#hide div" would yield an empty collection.
(Why wasn't this in the fixture in the first place?)
As a result moving fx-tests into the fixture a whole bunch of tests failed
that relied on arbitrary stuff about the document-wide or fixture-wide
state (e.g. number of divs etc.). So I had to adjust various tests to
limit their sample data to not be so variable and unlimited...
* Moved out tests for expando cleanup into a separate test.
* Fixed implied global variable 'pass' in effects.js that was causing
"TypeError: boolean is not a function" in *UNRELATED* dimensions.js that
uses a global variable "pass = function () {};" ...
* Removed spurious calls to _removeData. The new test exposed various failures
e.g. where div[0] isn't being assigned any data anyway.
(queue.js and attributes.js toggleClass).
* Removed spurious clean up at the bottom of test() functions that are
already covered by the teardown (calling QUnit.reset or removeClass to
supposedly undo any changes).
* Documented the parentheses-less magic line in toggleClass. It appeared that
it would always keep the current class name if there was any (since the
assignment started with "this.className || ...".
Adding parentheses + spacing is 8 bytes (though only 1 in gzip apparently).
Only added the comment for now, though I prefer clarity with logical
operators, I'd rather not face the yayMinPD[1] in this test-related commit.
* Updated QUnit urlConfig to the new format (raw string is deprecated).
* Clean up odd htmlentities in test titles, QUnit escapes this.
(^\s+test\(.*)(>\;) → $1>
(^\s+test\(.*)(<\;) → $1<
[1] jQuery MinJsGz Release Police Department (do the same, download less)
2012-10-17 08:33:47 +00:00
|
|
|
QUnit.expectJqData( $div[0], "olddisplay" );
|
2009-12-10 05:58:29 +00:00
|
|
|
});
|
2012-02-25 18:13:16 +00:00
|
|
|
|
2012-05-21 17:44:19 +00:00
|
|
|
test("passing undefined is a setter #5571", function() {
|
|
|
|
|
expect(4);
|
|
|
|
|
equal(jQuery("#nothiddendiv").height(30).height(undefined).height(), 30, ".height(undefined) is chainable (#5571)");
|
|
|
|
|
equal(jQuery("#nothiddendiv").height(30).innerHeight(undefined).height(), 30, ".innerHeight(undefined) is chainable (#5571)");
|
|
|
|
|
equal(jQuery("#nothiddendiv").height(30).outerHeight(undefined).height(), 30, ".outerHeight(undefined) is chainable (#5571)");
|
|
|
|
|
equal(jQuery("#nothiddendiv").width(30).width(undefined).width(), 30, ".width(undefined) is chainable (#5571)");
|
|
|
|
|
});
|
|
|
|
|
|
2012-08-19 20:30:10 +00:00
|
|
|
test( "getters on non elements should return null", function() {
|
|
|
|
|
expect( 8 );
|
|
|
|
|
|
|
|
|
|
var nonElem = jQuery("notAnElement");
|
|
|
|
|
|
|
|
|
|
strictEqual( nonElem.width(), null, ".width() is not null (#12283)" );
|
|
|
|
|
strictEqual( nonElem.innerWidth(), null, ".innerWidth() is not null (#12283)" );
|
|
|
|
|
strictEqual( nonElem.outerWidth(), null, ".outerWidth() is not null (#12283)" );
|
|
|
|
|
strictEqual( nonElem.outerWidth( true ), null, ".outerWidth(true) is not null (#12283)" );
|
|
|
|
|
|
|
|
|
|
strictEqual( nonElem.height(), null, ".height() is not null (#12283)" );
|
|
|
|
|
strictEqual( nonElem.innerHeight(), null, ".innerHeight() is not null (#12283)" );
|
|
|
|
|
strictEqual( nonElem.outerHeight(), null, ".outerHeight() is not null (#12283)" );
|
|
|
|
|
strictEqual( nonElem.outerHeight( true ), null, ".outerHeight(true) is not null (#12283)" );
|
|
|
|
|
});
|
|
|
|
|
|
2012-05-21 17:44:19 +00:00
|
|
|
test("setters with and without box-sizing:border-box", function(){
|
|
|
|
|
expect(20);
|
|
|
|
|
|
2014-02-05 14:59:38 +00:00
|
|
|
// Support: Firefox<29, Android 2.3 (Prefixed box-sizing versions).
|
2012-05-21 17:44:19 +00:00
|
|
|
var el_bb = jQuery("<div style='width:114px;height:114px;margin:5px;padding:3px;border:4px solid white;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box;'>test</div>").appendTo("#qunit-fixture"),
|
|
|
|
|
el = jQuery("<div style='width:100px;height:100px;margin:5px;padding:3px;border:4px solid white;'>test</div>").appendTo("#qunit-fixture"),
|
|
|
|
|
expected = 100;
|
|
|
|
|
|
|
|
|
|
equal( el_bb.width( 101 ).width(), expected + 1, "test border-box width(int) by roundtripping" );
|
|
|
|
|
equal( el_bb.innerWidth( 108 ).width(), expected + 2, "test border-box innerWidth(int) by roundtripping" );
|
|
|
|
|
equal( el_bb.outerWidth( 117 ).width(), expected + 3, "test border-box outerWidth(int) by roundtripping" );
|
|
|
|
|
equal( el_bb.outerWidth( 118, false ).width(), expected + 4, "test border-box outerWidth(int, false) by roundtripping" );
|
|
|
|
|
equal( el_bb.outerWidth( 129, true ).width(), expected + 5, "test border-box innerWidth(int, true) by roundtripping" );
|
|
|
|
|
|
|
|
|
|
equal( el_bb.height( 101 ).height(), expected + 1, "test border-box height(int) by roundtripping" );
|
|
|
|
|
equal( el_bb.innerHeight( 108 ).height(), expected + 2, "test border-box innerHeight(int) by roundtripping" );
|
|
|
|
|
equal( el_bb.outerHeight( 117 ).height(), expected + 3, "test border-box outerHeight(int) by roundtripping" );
|
|
|
|
|
equal( el_bb.outerHeight( 118, false ).height(), expected + 4, "test border-box outerHeight(int, false) by roundtripping" );
|
|
|
|
|
equal( el_bb.outerHeight( 129, true ).height(), expected + 5, "test border-box innerHeight(int, true) by roundtripping" );
|
|
|
|
|
|
|
|
|
|
equal( el.width( 101 ).width(), expected + 1, "test border-box width(int) by roundtripping" );
|
|
|
|
|
equal( el.innerWidth( 108 ).width(), expected + 2, "test border-box innerWidth(int) by roundtripping" );
|
|
|
|
|
equal( el.outerWidth( 117 ).width(), expected + 3, "test border-box outerWidth(int) by roundtripping" );
|
|
|
|
|
equal( el.outerWidth( 118, false ).width(), expected + 4, "test border-box outerWidth(int, false) by roundtripping" );
|
|
|
|
|
equal( el.outerWidth( 129, true ).width(), expected + 5, "test border-box innerWidth(int, true) by roundtripping" );
|
|
|
|
|
|
|
|
|
|
equal( el.height( 101 ).height(), expected + 1, "test border-box height(int) by roundtripping" );
|
|
|
|
|
equal( el.innerHeight( 108 ).height(), expected + 2, "test border-box innerHeight(int) by roundtripping" );
|
|
|
|
|
equal( el.outerHeight( 117 ).height(), expected + 3, "test border-box outerHeight(int) by roundtripping" );
|
|
|
|
|
equal( el.outerHeight( 118, false ).height(), expected + 4, "test border-box outerHeight(int, false) by roundtripping" );
|
|
|
|
|
equal( el.outerHeight( 129, true ).height(), expected + 5, "test border-box innerHeight(int, true) by roundtripping" );
|
|
|
|
|
});
|
|
|
|
|
|
2012-05-29 12:46:00 +00:00
|
|
|
testIframe( "dimensions/documentSmall", "window vs. small document", function( jQuery, window, document ) {
|
2012-06-06 21:06:03 +00:00
|
|
|
// this test is practically tautological, but there is a bug in IE8
|
|
|
|
|
// with no simple workaround, so this test exposes the bug and works around it
|
|
|
|
|
if ( document.body.offsetWidth >= document.documentElement.offsetWidth ) {
|
|
|
|
|
expect( 2 );
|
2012-02-25 18:13:16 +00:00
|
|
|
|
2012-06-06 21:06:03 +00:00
|
|
|
equal( jQuery( document ).height(), jQuery( window ).height(), "document height matches window height" );
|
|
|
|
|
equal( jQuery( document ).width(), jQuery( window ).width(), "document width matches window width" );
|
|
|
|
|
} else {
|
2012-08-09 14:42:09 +00:00
|
|
|
// all tests should have at least one assertion
|
|
|
|
|
expect( 1 );
|
|
|
|
|
ok( true, "skipping test (conditions not satisfied)" );
|
2012-06-06 21:06:03 +00:00
|
|
|
}
|
2012-02-25 18:13:16 +00:00
|
|
|
});
|
|
|
|
|
|
2012-05-29 12:46:00 +00:00
|
|
|
testIframe( "dimensions/documentLarge", "window vs. large document", function( jQuery, window, document ) {
|
2012-02-25 18:13:16 +00:00
|
|
|
expect(2);
|
|
|
|
|
|
2012-06-07 03:10:06 +00:00
|
|
|
ok( jQuery( document ).height() > jQuery( window ).height(), "document height is larger than window height" );
|
|
|
|
|
ok( jQuery( document ).width() > jQuery( window ).width(), "document width is larger than window width" );
|
2012-02-25 18:13:16 +00:00
|
|
|
});
|
2012-06-05 19:29:46 +00:00
|
|
|
|
2013-04-09 15:45:09 +00:00
|
|
|
})();
|
