guff-compass 0.7.0

data/demo/bower_components/jquery/test/unit/deferred.js

@@ -0,0 +1,436 @@
+module( "deferred", {
+	teardown: moduleTeardown
+});
+
+jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
+
+	function createDeferred( fn ) {
+		return withNew ? new jQuery.Deferred( fn ) : jQuery.Deferred( fn );
+	}
+
+	test( "jQuery.Deferred" + withNew, function() {
+
+		expect( 23 );
+
+		var defer = createDeferred();
+
+		strictEqual( defer.pipe, defer.then, "pipe is an alias of then" );
+
+		createDeferred().resolve().done(function() {
+			ok( true, "Success on resolve" );
+			strictEqual( this.state(), "resolved", "Deferred is resolved (state)" );
+		}).fail(function() {
+			ok( false, "Error on resolve" );
+		}).always(function() {
+			ok( true, "Always callback on resolve" );
+		});
+
+		createDeferred().reject().done(function() {
+			ok( false, "Success on reject" );
+		}).fail(function() {
+			ok( true, "Error on reject" );
+			strictEqual( this.state(), "rejected", "Deferred is rejected (state)" );
+		}).always(function() {
+			ok( true, "Always callback on reject" );
+		});
+
+		createDeferred(function( defer ) {
+			ok( this === defer, "Defer passed as this & first argument" );
+			this.resolve("done");
+		}).done(function( value ) {
+			strictEqual( value, "done", "Passed function executed" );
+		});
+
+		createDeferred(function( defer ) {
+			var promise = defer.promise(),
+				func = function() {},
+				funcPromise = defer.promise( func );
+			strictEqual( defer.promise(), promise, "promise is always the same" );
+			strictEqual( funcPromise, func, "non objects get extended" );
+			jQuery.each( promise, function( key ) {
+				if ( !jQuery.isFunction( promise[ key ] ) ) {
+					ok( false, key + " is a function (" + jQuery.type( promise[ key ] ) + ")" );
+				}
+				if ( promise[ key ] !== func[ key ] ) {
+					strictEqual( func[ key ], promise[ key ], key + " is the same" );
+				}
+			});
+		});
+
+		jQuery.expandedEach = jQuery.each;
+		jQuery.expandedEach( "resolve reject".split(" "), function( _, change ) {
+			createDeferred(function( defer ) {
+				strictEqual( defer.state(), "pending", "pending after creation" );
+				var checked = 0;
+				defer.progress(function( value ) {
+					strictEqual( value, checked, "Progress: right value (" + value + ") received" );
+				});
+				for ( checked = 0; checked < 3; checked++ ) {
+					defer.notify( checked );
+				}
+				strictEqual( defer.state(), "pending", "pending after notification" );
+				defer[ change ]();
+				notStrictEqual( defer.state(), "pending", "not pending after " + change );
+				defer.notify();
+			});
+		});
+	});
+});
+
+
+test( "jQuery.Deferred - chainability", function() {
+
+	var defer = jQuery.Deferred();
+
+	expect( 10 );
+
+	jQuery.expandedEach = jQuery.each;
+	jQuery.expandedEach( "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split(" "), function( _, method ) {
+		var object = {
+			m: defer[ method ]
+		};
+		strictEqual( object.m(), object, method + " is chainable" );
+	});
+});
+
+test( "jQuery.Deferred.then - filtering (done)", function() {
+
+	expect( 4 );
+
+	var value1, value2, value3,
+		defer = jQuery.Deferred(),
+		piped = defer.then(function( a, b ) {
+			return a * b;
+		});
+
+	piped.done(function( result ) {
+		value3 = result;
+	});
+
+	defer.done(function( a, b ) {
+		value1 = a;
+		value2 = b;
+	});
+
+	defer.resolve( 2, 3 );
+
+	strictEqual( value1, 2, "first resolve value ok" );
+	strictEqual( value2, 3, "second resolve value ok" );
+	strictEqual( value3, 6, "result of filter ok" );
+
+	jQuery.Deferred().reject().then(function() {
+		ok( false, "then should not be called on reject" );
+	});
+
+	jQuery.Deferred().resolve().then( jQuery.noop ).done(function( value ) {
+		strictEqual( value, undefined, "then done callback can return undefined/null" );
+	});
+});
+
+test( "jQuery.Deferred.then - filtering (fail)", function() {
+
+	expect( 4 );
+
+	var value1, value2, value3,
+		defer = jQuery.Deferred(),
+		piped = defer.then( null, function( a, b ) {
+			return a * b;
+		});
+
+	piped.fail(function( result ) {
+		value3 = result;
+	});
+
+	defer.fail(function( a, b ) {
+		value1 = a;
+		value2 = b;
+	});
+
+	defer.reject( 2, 3 );
+
+	strictEqual( value1, 2, "first reject value ok" );
+	strictEqual( value2, 3, "second reject value ok" );
+	strictEqual( value3, 6, "result of filter ok" );
+
+	jQuery.Deferred().resolve().then( null, function() {
+		ok( false, "then should not be called on resolve" );
+	});
+
+	jQuery.Deferred().reject().then( null, jQuery.noop ).fail(function( value ) {
+		strictEqual( value, undefined, "then fail callback can return undefined/null" );
+	});
+});
+
+test( "jQuery.Deferred.then - filtering (progress)", function() {
+
+	expect( 3 );
+
+	var value1, value2, value3,
+		defer = jQuery.Deferred(),
+		piped = defer.then( null, null, function( a, b ) {
+			return a * b;
+		});
+
+	piped.progress(function( result ) {
+		value3 = result;
+	});
+
+	defer.progress(function( a, b ) {
+		value1 = a;
+		value2 = b;
+	});
+
+	defer.notify( 2, 3 );
+
+	strictEqual( value1, 2, "first progress value ok" );
+	strictEqual( value2, 3, "second progress value ok" );
+	strictEqual( value3, 6, "result of filter ok" );
+});
+
+test( "jQuery.Deferred.then - deferred (done)", function() {
+
+	expect( 3 );
+
+	var value1, value2, value3,
+		defer = jQuery.Deferred(),
+		piped = defer.then(function( a, b ) {
+			return jQuery.Deferred(function( defer ) {
+				defer.reject( a * b );
+			});
+		});
+
+	piped.fail(function( result ) {
+		value3 = result;
+	});
+
+	defer.done(function( a, b ) {
+		value1 = a;
+		value2 = b;
+	});
+
+	defer.resolve( 2, 3 );
+
+	strictEqual( value1, 2, "first resolve value ok" );
+	strictEqual( value2, 3, "second resolve value ok" );
+	strictEqual( value3, 6, "result of filter ok" );
+});
+
+test( "jQuery.Deferred.then - deferred (fail)", function() {
+
+	expect( 3 );
+
+	var value1, value2, value3,
+		defer = jQuery.Deferred(),
+		piped = defer.then( null, function( a, b ) {
+			return jQuery.Deferred(function( defer ) {
+				defer.resolve( a * b );
+			});
+		});
+
+	piped.done(function( result ) {
+		value3 = result;
+	});
+
+	defer.fail(function( a, b ) {
+		value1 = a;
+		value2 = b;
+	});
+
+	defer.reject( 2, 3 );
+
+	strictEqual( value1, 2, "first reject value ok" );
+	strictEqual( value2, 3, "second reject value ok" );
+	strictEqual( value3, 6, "result of filter ok" );
+});
+
+test( "jQuery.Deferred.then - deferred (progress)", function() {
+
+	expect( 3 );
+
+	var value1, value2, value3,
+		defer = jQuery.Deferred(),
+		piped = defer.then( null, null, function( a, b ) {
+			return jQuery.Deferred(function( defer ) {
+				defer.resolve( a * b );
+			});
+		});
+
+	piped.done(function( result ) {
+		value3 = result;
+	});
+
+	defer.progress(function( a, b ) {
+		value1 = a;
+		value2 = b;
+	});
+
+	defer.notify( 2, 3 );
+
+	strictEqual( value1, 2, "first progress value ok" );
+	strictEqual( value2, 3, "second progress value ok" );
+	strictEqual( value3, 6, "result of filter ok" );
+});
+
+test( "jQuery.Deferred.then - context", function() {
+
+	expect( 7 );
+
+	var defer, piped, defer2, piped2,
+		context = {};
+
+	jQuery.Deferred().resolveWith( context, [ 2 ] ).then(function( value ) {
+		return value * 3;
+	}).done(function( value ) {
+		strictEqual( this, context, "custom context correctly propagated" );
+		strictEqual( value, 6, "proper value received" );
+	});
+
+	jQuery.Deferred().resolve().then(function() {
+		return jQuery.Deferred().resolveWith(context);
+	}).done(function() {
+		strictEqual( this, context, "custom context of returned deferred correctly propagated" );
+	});
+
+	defer = jQuery.Deferred();
+	piped = defer.then(function( value ) {
+		return value * 3;
+	});
+
+	defer.resolve( 2 );
+
+	piped.done(function( value ) {
+		strictEqual( this, piped, "default context gets updated to latest promise in the chain" );
+		strictEqual( value, 6, "proper value received" );
+	});
+
+	defer2 = jQuery.Deferred();
+	piped2 = defer2.then();
+
+	defer2.resolve( 2 );
+
+	piped2.done(function( value ) {
+		strictEqual( this, piped2, "default context gets updated to latest promise in the chain (without passing function)" );
+		strictEqual( value, 2, "proper value received (without passing function)" );
+	});
+});
+
+test( "jQuery.when", function() {
+
+	expect( 34 );
+
+	// Some other objects
+	jQuery.each({
+		"an empty string": "",
+		"a non-empty string": "some string",
+		"zero": 0,
+		"a number other than zero": 1,
+		"true": true,
+		"false": false,
+		"null": null,
+		"undefined": undefined,
+		"a plain object": {}
+	}, function( message, value ) {
+		ok(
+			jQuery.isFunction(
+				jQuery.when( value ).done(function( resolveValue ) {
+					strictEqual( this, window, "Context is the global object with " + message );
+					strictEqual( resolveValue, value, "Test the promise was resolved with " + message );
+				}).promise
+			),
+			"Test " + message + " triggers the creation of a new Promise"
+		);
+	});
+
+	ok(
+		jQuery.isFunction(
+			jQuery.when().done(function( resolveValue ) {
+				strictEqual( this, window, "Test the promise was resolved with window as its context" );
+				strictEqual( resolveValue, undefined, "Test the promise was resolved with no parameter" );
+			}).promise
+		),
+		"Test calling when with no parameter triggers the creation of a new Promise"
+	);
+
+	var cache,
+		context = {};
+
+	jQuery.when( jQuery.Deferred().resolveWith( context ) ).done(function() {
+		strictEqual( this, context, "when( promise ) propagates context" );
+	});
+
+	jQuery.each([ 1, 2, 3 ], function( k, i ) {
+
+		jQuery.when( cache || jQuery.Deferred(function() {
+				this.resolve( i );
+			})
+		).done(function( value ) {
+
+			strictEqual( value, 1, "Function executed" + ( i > 1 ? " only once" : "" ) );
+			cache = value;
+		});
+
+	});
+});
+
+test( "jQuery.when - joined", function() {
+
+	expect( 119 );
+
+	var deferreds = {
+			value: 1,
+			success: jQuery.Deferred().resolve( 1 ),
+			error: jQuery.Deferred().reject( 0 ),
+			futureSuccess: jQuery.Deferred().notify( true ),
+			futureError: jQuery.Deferred().notify( true ),
+			notify: jQuery.Deferred().notify( true )
+		},
+		willSucceed = {
+			value: true,
+			success: true,
+			futureSuccess: true
+		},
+		willError = {
+			error: true,
+			futureError: true
+		},
+		willNotify = {
+			futureSuccess: true,
+			futureError: true,
+			notify: true
+		};
+
+	jQuery.each( deferreds, function( id1, defer1 ) {
+		jQuery.each( deferreds, function( id2, defer2 ) {
+			var shouldResolve = willSucceed[ id1 ] && willSucceed[ id2 ],
+				shouldError = willError[ id1 ] || willError[ id2 ],
+				shouldNotify = willNotify[ id1 ] || willNotify[ id2 ],
+				expected = shouldResolve ? [ 1, 1 ] : [ 0, undefined ],
+				expectedNotify = shouldNotify && [ willNotify[ id1 ], willNotify[ id2 ] ],
+				code = id1 + "/" + id2,
+				context1 = defer1 && jQuery.isFunction( defer1.promise ) ? defer1.promise() : undefined,
+				context2 = defer2 && jQuery.isFunction( defer2.promise ) ? defer2.promise() : undefined;
+
+			jQuery.when( defer1, defer2 ).done(function( a, b ) {
+				if ( shouldResolve ) {
+					deepEqual( [ a, b ], expected, code + " => resolve" );
+					strictEqual( this[ 0 ], context1, code + " => first context OK" );
+					strictEqual( this[ 1 ], context2, code + " => second context OK" );
+				} else {
+					ok( false,  code + " => resolve" );
+				}
+			}).fail(function( a, b ) {
+				if ( shouldError ) {
+					deepEqual( [ a, b ], expected, code + " => reject" );
+				} else {
+					ok( false, code + " => reject" );
+				}
+			}).progress(function( a, b ) {
+				deepEqual( [ a, b ], expectedNotify, code + " => progress" );
+				strictEqual( this[ 0 ], expectedNotify[ 0 ] ? context1 : undefined, code + " => first context OK" );
+				strictEqual( this[ 1 ], expectedNotify[ 1 ] ? context2 : undefined, code + " => second context OK" );
+			});
+		});
+	});
+	deferreds.futureSuccess.resolve( 1 );
+	deferreds.futureError.reject( 0 );
+});

data/demo/bower_components/jquery/test/unit/deprecated.js

@@ -0,0 +1,8 @@
+module("deprecated", { teardown: moduleTeardown });
+
+if ( jQuery.fn.size ) {
+	test("size()", function() {
+		expect(1);
+		equal( jQuery("#qunit-fixture p").size(), 6, "Get Number of Elements Found" );
+	});
+}

data/demo/bower_components/jquery/test/unit/dimensions.js

@@ -0,0 +1,472 @@
+(function() {
+
+if ( !jQuery.fn.width ) {
+	return;
+}
+
+module("dimensions", { teardown: moduleTeardown });
+
+function pass( val ) {
+	return val;
+}
+
+function fn( val ) {
+	return function() {
+		return val;
+	};
+}
+
+/*
+	======== 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
+*/
+
+function testWidth( val ) {
+	expect(9);
+	var $div, blah;
+
+	$div = jQuery("#nothiddendiv");
+	$div.width( val(30) );
+	equal($div.width(), 30, "Test set to 30 correctly");
+	$div.hide();
+	equal($div.width(), 30, "Test hidden div");
+	$div.show();
+	$div.width( val(-1) ); // handle negative numbers by setting to 0 #11604
+	equal($div.width(), 0, "Test negative width normalized to 0");
+	$div.css("padding", "20px");
+	equal($div.width(), 0, "Test padding specified with pixels");
+	$div.css("border", "2px solid #fff");
+	equal($div.width(), 0, "Test border specified with pixels");
+
+	$div.css({ "display": "", "border": "", "padding": "" });
+
+	jQuery("#nothiddendivchild").css({ "width": 20, "padding": "3px", "border": "2px solid #fff" });
+	equal(jQuery("#nothiddendivchild").width(), 20, "Test child width with border and padding");
+	jQuery("#nothiddendiv, #nothiddendivchild").css({ "border": "", "padding": "", "width": "" });
+
+	blah = jQuery("blah");
+	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");
+
+	equal( jQuery(window).width(), document.documentElement.clientWidth, "Window width is equal to width reported by window/document." );
+
+	QUnit.expectJqData( $div[0], "olddisplay" );
+}
+
+test("width()", function() {
+	testWidth( pass );
+});
+
+test("width(Function)", function() {
+	testWidth( fn );
+});
+
+test("width(Function(args))", function() {
+	expect( 2 );
+
+	var $div = jQuery("#nothiddendiv");
+	$div.width( 30 ).width(function(i, width) {
+		equal( width, 30, "Make sure previous value is correct." );
+		return width + 1;
+	});
+
+	equal( $div.width(), 31, "Make sure value was modified correctly." );
+});
+
+function testHeight( val ) {
+	expect(9);
+
+	var $div, blah;
+
+	$div = jQuery("#nothiddendiv");
+	$div.height( val(30) );
+	equal($div.height(), 30, "Test set to 30 correctly");
+	$div.hide();
+	equal($div.height(), 30, "Test hidden div");
+	$div.show();
+	$div.height( val(-1) ); // handle negative numbers by setting to 0 #11604
+	equal($div.height(), 0, "Test negative height normalized to 0");
+	$div.css("padding", "20px");
+	equal($div.height(), 0, "Test padding specified with pixels");
+	$div.css("border", "2px solid #fff");
+	equal($div.height(), 0, "Test border specified with pixels");
+
+	$div.css({ "display": "", "border": "", "padding": "", "height": "1px" });
+
+	jQuery("#nothiddendivchild").css({ "height": 20, "padding": "3px", "border": "2px solid #fff" });
+	equal(jQuery("#nothiddendivchild").height(), 20, "Test child height with border and padding");
+	jQuery("#nothiddendiv, #nothiddendivchild").css({ "border": "", "padding": "", "height": "" });
+
+	blah = jQuery("blah");
+	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");
+
+	equal( jQuery(window).height(), document.documentElement.clientHeight, "Window width is equal to width reported by window/document." );
+
+	QUnit.expectJqData( $div[0], "olddisplay" );
+}
+
+test("height()", function() {
+	testHeight( pass );
+});
+
+test("height(Function)", function() {
+	testHeight( fn );
+});
+
+test("height(Function(args))", function() {
+	expect( 2 );
+
+	var $div = jQuery("#nothiddendiv");
+	$div.height( 30 ).height(function(i, height) {
+		equal( height, 30, "Make sure previous value is correct." );
+		return height + 1;
+	});
+
+	equal( $div.height(), 31, "Make sure value was modified correctly." );
+});
+
+test("innerWidth()", function() {
+	expect(6);
+
+	var $div, div,
+		winWidth = jQuery( window ).width(),
+		docWidth = jQuery( document ).width();
+
+	equal(jQuery(window).innerWidth(), winWidth, "Test on window");
+	equal(jQuery(document).innerWidth(), docWidth, "Test on document");
+
+	$div = jQuery("#nothiddendiv");
+	// set styles
+	$div.css({
+		"margin": 10,
+		"border": "2px solid #fff",
+		"width": 30
+	});
+
+	equal($div.innerWidth(), 30, "Test with margin and border");
+	$div.css("padding", "20px");
+	equal($div.innerWidth(), 70, "Test with margin, border and padding");
+	$div.hide();
+	equal($div.innerWidth(), 70, "Test hidden div");
+
+	// reset styles
+	$div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
+
+	div = jQuery( "<div>" );
+
+	// Temporarily require 0 for backwards compat - should be auto
+	equal( div.innerWidth(), 0, "Make sure that disconnected nodes are handled." );
+
+	div.remove();
+	QUnit.expectJqData( $div[0], "olddisplay" );
+});
+
+test("innerHeight()", function() {
+	expect(6);
+
+	var $div, div,
+		winHeight = jQuery( window ).height(),
+		docHeight = jQuery( document ).height();
+
+	equal(jQuery(window).innerHeight(), winHeight, "Test on window");
+	equal(jQuery(document).innerHeight(), docHeight, "Test on document");
+
+	$div = jQuery("#nothiddendiv");
+	// set styles
+	$div.css({
+		"margin": 10,
+		"border": "2px solid #fff",
+		"height": 30
+	});
+
+	equal($div.innerHeight(), 30, "Test with margin and border");
+	$div.css("padding", "20px");
+	equal($div.innerHeight(), 70, "Test with margin, border and padding");
+	$div.hide();
+	equal($div.innerHeight(), 70, "Test hidden div");
+
+	// reset styles
+	$div.css({ "display": "", "border": "", "padding": "", "width": "", "height": "" });
+
+	div = jQuery( "<div>" );
+
+	// Temporarily require 0 for backwards compat - should be auto
+	equal( div.innerHeight(), 0, "Make sure that disconnected nodes are handled." );
+
+	div.remove();
+	QUnit.expectJqData( $div[0], "olddisplay" );
+});
+
+test("outerWidth()", function() {
+	expect(11);
+
+	var $div, div,
+	winWidth = jQuery( window ).width(),
+		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" );
+
+	$div = jQuery("#nothiddendiv");
+	$div.css("width", 30);
+
+	equal($div.outerWidth(), 30, "Test with only width set");
+	$div.css("padding", "20px");
+	equal($div.outerWidth(), 70, "Test with padding");
+	$div.css("border", "2px solid #fff");
+	equal($div.outerWidth(), 74, "Test with padding and border");
+	$div.css("margin", "10px");
+	equal($div.outerWidth(), 74, "Test with padding, border and margin without margin option");
+	$div.css("position", "absolute");
+	equal($div.outerWidth(true), 94, "Test with padding, border and margin with margin option");
+	$div.hide();
+	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 = jQuery( "<div>" );
+
+	// Temporarily require 0 for backwards compat - should be auto
+	equal( div.outerWidth(), 0, "Make sure that disconnected nodes are handled." );
+
+	div.remove();
+	QUnit.expectJqData( $div[0], "olddisplay" );
+});
+
+test("child of a hidden elem (or unconnected node) has accurate inner/outer/Width()/Height()  see #9441 #9300", function() {
+	expect(16);
+
+	// setup html
+	var $divNormal = jQuery("<div>").css({ "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" }),
+		$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 #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" );
+
+	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" );
+
+	// 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" );
+
+	// teardown html
+	$divHiddenParent.remove();
+	$divNormal.remove();
+});
+
+test("getting dimensions shouldn't modify runtimeStyle see #9233", function() {
+	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 {
+		ok( true, "this browser doesn't support runtimeStyle, see #9233" );
+	}
+
+	$div.remove();
+});
+
+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"),
+		tdElem = table.find("td").first(),
+		colElem = table.find("col").first().width( 300 );
+
+	table.find("td").css({ "margin": 0, "padding": 0 });
+
+	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" );
+});
+
+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
+	var $divNormal = jQuery("<div>").css({ "boxSizing": "border-box", "width": "100px", "height": "100px", "border": "10px solid white", "padding": "2px", "margin": "3px" }),
+		$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();
+});
+
+test("outerHeight()", function() {
+	expect(11);
+
+	var $div, div,
+	winHeight = jQuery( window ).height(),
+		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" );
+
+	$div = jQuery("#nothiddendiv");
+	$div.css("height", 30);
+
+	equal($div.outerHeight(), 30, "Test with only width set");
+	$div.css("padding", "20px");
+	equal($div.outerHeight(), 70, "Test with padding");
+	$div.css("border", "2px solid #fff");
+	equal($div.outerHeight(), 74, "Test with padding and border");
+	$div.css("margin", "10px");
+	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");
+	$div.hide();
+	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 = jQuery( "<div>" );
+
+	// Temporarily require 0 for backwards compat - should be auto
+	equal( div.outerHeight(), 0, "Make sure that disconnected nodes are handled." );
+
+	div.remove();
+	QUnit.expectJqData( $div[0], "olddisplay" );
+});
+
+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)");
+});
+
+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)" );
+});
+
+test("setters with and without box-sizing:border-box", function(){
+	expect(20);
+
+	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" );
+});
+
+testIframe( "dimensions/documentSmall", "window vs. small document", function( jQuery, window, document ) {
+	// 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 );
+
+		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 {
+		// all tests should have at least one assertion
+		expect( 1 );
+		ok( true, "skipping test (conditions not satisfied)" );
+	}
+});
+
+testIframe( "dimensions/documentLarge", "window vs. large document", function( jQuery, window, document ) {
+	expect(2);
+
+	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" );
+});
+
+})();