guff-compass 0.7.0

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

@@ -0,0 +1,314 @@
+module( "queue", { teardown: moduleTeardown });
+
+test( "queue() with other types", 14, function() {
+	stop();
+
+	var $div = jQuery({}),
+		counter = 0;
+
+	$div.promise( "foo" ).done(function() {
+		equal( counter, 0, "Deferred for collection with no queue is automatically resolved" );
+	});
+
+	$div
+		.queue("foo",function(){
+			equal( ++counter, 1, "Dequeuing" );
+			jQuery.dequeue(this,"foo");
+		})
+		.queue("foo",function(){
+			equal( ++counter, 2, "Dequeuing" );
+			jQuery(this).dequeue("foo");
+		})
+		.queue("foo",function(){
+			equal( ++counter, 3, "Dequeuing" );
+		})
+		.queue("foo",function(){
+			equal( ++counter, 4, "Dequeuing" );
+		});
+
+	$div.promise("foo").done(function() {
+		equal( counter, 4, "Testing previous call to dequeue in deferred"  );
+		start();
+	});
+
+	equal( $div.queue("foo").length, 4, "Testing queue length" );
+
+	equal( $div.queue("foo", undefined).queue("foo").length, 4, ".queue('name',undefined) does nothing but is chainable (#5571)");
+
+	$div.dequeue("foo");
+
+	equal( counter, 3, "Testing previous call to dequeue" );
+	equal( $div.queue("foo").length, 1, "Testing queue length" );
+
+	$div.dequeue("foo");
+
+	equal( counter, 4, "Testing previous call to dequeue" );
+	equal( $div.queue("foo").length, 0, "Testing queue length" );
+
+	$div.dequeue("foo");
+
+	equal( counter, 4, "Testing previous call to dequeue" );
+	equal( $div.queue("foo").length, 0, "Testing queue length" );
+
+});
+
+test("queue(name) passes in the next item in the queue as a parameter", function() {
+	expect(2);
+
+	var div = jQuery({}),
+		counter = 0;
+
+	div.queue("foo", function(next) {
+		equal(++counter, 1, "Dequeueing");
+		next();
+	}).queue("foo", function(next) {
+		equal(++counter, 2, "Next was called");
+		next();
+	}).queue("bar", function() {
+		equal(++counter, 3, "Other queues are not triggered by next()");
+	});
+
+	div.dequeue("foo");
+});
+
+test("queue() passes in the next item in the queue as a parameter to fx queues", function() {
+	expect(3);
+	stop();
+
+	var div = jQuery({}),
+		counter = 0;
+
+	div.queue(function( next ) {
+		equal(++counter, 1, "Dequeueing");
+		setTimeout(function() { next(); }, 500);
+	}).queue(function(next) {
+		equal(++counter, 2, "Next was called");
+		next();
+	}).queue("bar", function() {
+		equal(++counter, 3, "Other queues are not triggered by next()");
+	});
+
+	jQuery.when( div.promise("fx"), div ).done(function() {
+		equal(counter, 2, "Deferreds resolved");
+		start();
+	});
+});
+
+test("callbacks keep their place in the queue", function() {
+	expect(5);
+	stop();
+	var div = jQuery("<div>"),
+		counter = 0;
+
+	div.queue(function( next ) {
+		equal( ++counter, 1, "Queue/callback order: first called" );
+		setTimeout( next, 200 );
+	}).delay( 100 ).queue(function( next ) {
+		equal( ++counter, 2, "Queue/callback order: second called" );
+		jQuery( this ).delay( 100 ).queue(function( next ) {
+			equal( ++counter, 4, "Queue/callback order: fourth called" );
+			next();
+		});
+		next();
+	}).queue(function( next ) {
+		equal( ++counter, 3, "Queue/callback order: third called" );
+		next();
+	});
+
+	div.promise("fx").done(function() {
+		equal(counter, 4, "Deferreds resolved");
+		start();
+	});
+});
+
+test("delay()", function() {
+	expect(2);
+	stop();
+
+	var foo = jQuery({}), run = 0;
+
+	foo.delay(100).queue(function(){
+		run = 1;
+		ok( true, "The function was dequeued." );
+		start();
+	});
+
+	equal( run, 0, "The delay delayed the next function from running." );
+});
+
+test("clearQueue(name) clears the queue", function() {
+	expect(2);
+
+	stop();
+
+	var div = jQuery({}),
+		counter = 0;
+
+	div.queue("foo", function( next ) {
+		counter++;
+		jQuery(this).clearQueue("foo");
+		next();
+	}).queue("foo", function() {
+		counter++;
+	});
+
+	div.promise("foo").done(function() {
+		ok( true, "dequeue resolves the deferred" );
+		start();
+	});
+
+	div.dequeue("foo");
+
+	equal(counter, 1, "the queue was cleared");
+});
+
+test("clearQueue() clears the fx queue", function() {
+	expect(1);
+
+	var div = jQuery({}),
+		counter = 0;
+
+	div.queue(function( next ) {
+		counter++;
+		var self = this;
+		setTimeout(function() { jQuery(self).clearQueue(); next(); }, 50);
+	}).queue(function() {
+		counter++;
+	});
+
+	equal(counter, 1, "the queue was cleared");
+
+	div.removeData();
+});
+
+asyncTest( "fn.promise() - called when fx queue is empty", 3, function() {
+	var foo = jQuery( "#foo" ).clone().addBack(),
+		promised = false;
+
+	foo.queue( function( next ) {
+		// called twice!
+		ok( !promised, "Promised hasn't been called" );
+		setTimeout( next, 10 );
+	});
+	foo.promise().done( function() {
+		ok( promised = true, "Promised" );
+		start();
+	});
+});
+
+asyncTest( "fn.promise( \"queue\" ) - called whenever last queue function is dequeued", 5, function() {
+	var foo = jQuery( "#foo" ),
+		test;
+	foo.promise( "queue" ).done( function() {
+		strictEqual( test, undefined, "called immediately when queue was already empty" );
+	});
+	test = 1;
+	foo.queue( "queue", function( next ) {
+		strictEqual( test++, 1, "step one" );
+		setTimeout( next, 0 );
+	}).queue( "queue", function( next ) {
+		strictEqual( test++, 2, "step two" );
+		setTimeout( function() {
+			next();
+			strictEqual( test++, 4, "step four" );
+			start();
+		}, 10 );
+	}).promise( "queue" ).done( function() {
+		strictEqual( test++, 3, "step three" );
+	});
+
+	foo.dequeue( "queue" );
+});
+
+asyncTest( "fn.promise( \"queue\" ) - waits for animation to complete before resolving", 2, function() {
+	var foo = jQuery( "#foo" ),
+		test = 1;
+
+	foo.animate({
+		top: 100
+	}, {
+		duration: 1,
+		queue: "queue",
+		complete: function() {
+			strictEqual( test++, 1, "step one" );
+		}
+	}).dequeue( "queue" );
+
+	foo.promise( "queue" ).done( function() {
+		strictEqual( test++, 2, "step two" );
+		start();
+	});
+
+});
+
+test( ".promise(obj)", function() {
+	expect(2);
+
+	var obj = {},
+		promise = jQuery( "#foo" ).promise( "promise", obj );
+
+	ok( jQuery.isFunction( promise.promise ), ".promise(type, obj) returns a promise" );
+	strictEqual( promise, obj, ".promise(type, obj) returns obj" );
+});
+
+
+if ( jQuery.fn.stop ) {
+	test("delay() can be stopped", function() {
+		expect( 3 );
+		stop();
+
+		var done = {};
+		jQuery({})
+			.queue( "alternate", function( next ) {
+				done.alt1 = true;
+				ok( true, "This first function was dequeued" );
+				next();
+			})
+			.delay( 1000, "alternate" )
+			.queue( "alternate", function() {
+				done.alt2 = true;
+				ok( true, "The function was dequeued immediately, the delay was stopped" );
+			})
+			.dequeue( "alternate" )
+
+			// stop( "alternate", false ) will NOT clear the queue, so it should automatically dequeue the next
+			.stop( "alternate", false, false )
+
+			// this test
+			.delay( 1 )
+			.queue(function() {
+				done.default1 = true;
+				ok( false, "This queue should never run" );
+			})
+
+			// stop( clearQueue ) should clear the queue
+			.stop( true, false );
+
+		deepEqual( done, { alt1: true, alt2: true }, "Queue ran the proper functions" );
+
+		setTimeout(function() {
+			start();
+		}, 1500 );
+	});
+
+	asyncTest( "queue stop hooks", 2, function() {
+		var foo = jQuery( "#foo" );
+
+		foo.queue( function( next, hooks ) {
+			hooks.stop = function( gotoEnd ) {
+				equal( !!gotoEnd, false, "Stopped without gotoEnd" );
+			};
+		});
+		foo.stop();
+
+		foo.queue( function( next, hooks ) {
+			hooks.stop = function( gotoEnd ) {
+				equal( gotoEnd, true, "Stopped with gotoEnd" );
+				start();
+			};
+		});
+
+		foo.stop( false, true );
+	});
+
+} // if ( jQuery.fn.stop )

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

@@ -0,0 +1,172 @@
+module("selector", { teardown: moduleTeardown });
+
+/**
+ * This test page is for selector tests that require jQuery in order to do the selection
+ */
+
+test("element - jQuery only", function() {
+	expect( 7 );
+
+	var fixture = document.getElementById("qunit-fixture");
+
+	deepEqual( jQuery("p", fixture).get(), q("firstp","ap","sndp","en","sap","first"), "Finding elements with a Node context." );
+	deepEqual( jQuery("p", "#qunit-fixture").get(), q("firstp","ap","sndp","en","sap","first"), "Finding elements with a selector context." );
+	deepEqual( jQuery("p", jQuery("#qunit-fixture")).get(), q("firstp","ap","sndp","en","sap","first"), "Finding elements with a jQuery object context." );
+	deepEqual( jQuery("#qunit-fixture").find("p").get(), q("firstp","ap","sndp","en","sap","first"), "Finding elements with a context via .find()." );
+
+	ok( jQuery("#length").length, "<input name=\"length\"> cannot be found under IE, see #945" );
+	ok( jQuery("#lengthtest input").length, "<input name=\"length\"> cannot be found under IE, see #945" );
+
+	// #7533
+	equal( jQuery("<div id=\"A'B~C.D[E]\"><p>foo</p></div>").find("p").length, 1, "Find where context root is a node and has an ID with CSS3 meta characters" );
+});
+
+test("class - jQuery only", function() {
+	expect( 4 );
+
+	deepEqual( jQuery(".blog", document.getElementsByTagName("p")).get(), q("mark", "simon"), "Finding elements with a context." );
+	deepEqual( jQuery(".blog", "p").get(), q("mark", "simon"), "Finding elements with a context." );
+	deepEqual( jQuery(".blog", jQuery("p")).get(), q("mark", "simon"), "Finding elements with a context." );
+	deepEqual( jQuery("p").find(".blog").get(), q("mark", "simon"), "Finding elements with a context." );
+});
+
+test("attributes - jQuery only", function() {
+	expect( 5 );
+
+	t( "Find elements with a tabindex attribute", "[tabindex]", ["listWithTabIndex", "foodWithNegativeTabIndex", "linkWithTabIndex", "linkWithNegativeTabIndex", "linkWithNoHrefWithTabIndex", "linkWithNoHrefWithNegativeTabIndex"] );
+
+	// #12600
+	ok(
+		jQuery("<select value='12600'><option value='option' selected='selected'></option><option value=''></option></select>")
+		.prop( "value", "option" )
+		.is(":input[value='12600']"),
+
+		":input[value=foo] selects select by attribute"
+	);
+	ok( jQuery("<input type='text' value='12600'/>").prop( "value", "option" ).is(":input[value='12600']"),
+		":input[value=foo] selects text input by attribute"
+	);
+
+	// #11115
+	ok( jQuery("<input type='checkbox' checked='checked'/>").prop( "checked", false ).is("[checked]"),
+		"[checked] selects by attribute (positive)"
+	);
+	ok( !jQuery("<input type='checkbox'/>").prop( "checked", true ).is("[checked]"),
+		"[checked] selects by attribute (negative)"
+	);
+});
+
+test("disconnected nodes", function() {
+	expect( 1 );
+
+	var $div = jQuery("<div/>");
+	equal( $div.is("div"), true, "Make sure .is('nodeName') works on disconnected nodes." );
+});
+
+test("disconnected nodes - jQuery only", function() {
+	expect( 3 );
+
+	var $opt = jQuery("<option></option>").attr("value", "whipit").appendTo("#qunit-fixture").detach();
+	equal( $opt.val(), "whipit", "option value" );
+	equal( $opt.is(":selected"), false, "unselected option" );
+	$opt.prop("selected", true);
+	equal( $opt.is(":selected"), true, "selected option" );
+});
+
+testIframe("selector/html5_selector", "attributes - jQuery.attr", function( jQuery, window, document ) {
+	expect( 35 );
+
+	/**
+	 * Returns an array of elements with the given IDs
+	 * q & t are added here for the iFrame's context
+	 */
+	function q() {
+		var r = [],
+			i = 0;
+
+		for ( ; i < arguments.length; i++ ) {
+			r.push( document.getElementById( arguments[i] ) );
+		}
+		return r;
+	}
+
+	/**
+	 * Asserts that a select matches the given IDs
+	 * @example t("Check for something", "//[a]", ["foo", "baar"]);
+	 * @param {String} a - Assertion name
+	 * @param {String} b - Sizzle selector
+	 * @param {Array} c - Array of ids to construct what is expected
+	 */
+	function t( a, b, c ) {
+		var f = jQuery(b).get(),
+			s = "",
+			i = 0;
+
+		for ( ; i < f.length; i++ ) {
+			s += (s && ",") + "'" + f[i].id + "'";
+		}
+
+		deepEqual(f, q.apply( q, c ), a + " (" + b + ")");
+	}
+
+	// ====== All known boolean attributes, including html5 booleans ======
+	// autobuffer, autofocus, autoplay, async, checked,
+	// compact, controls, declare, defer, disabled,
+	// formnovalidate, hidden, indeterminate (property only),
+	// ismap, itemscope, loop, multiple, muted, nohref, noresize,
+	// noshade, nowrap, novalidate, open, pubdate, readonly, required,
+	// reversed, scoped, seamless, selected, truespeed, visible (skipping visible attribute, which is on a barprop object)
+
+	t( "Attribute Exists", "[autobuffer]",     ["video1"]);
+	t( "Attribute Exists", "[autofocus]",      ["text1"]);
+	t( "Attribute Exists", "[autoplay]",       ["video1"]);
+	t( "Attribute Exists", "[async]",          ["script1"]);
+	t( "Attribute Exists", "[checked]",        ["check1"]);
+	t( "Attribute Exists", "[compact]",        ["dl"]);
+	t( "Attribute Exists", "[controls]",       ["video1"]);
+	t( "Attribute Exists", "[declare]",        ["object1"]);
+	t( "Attribute Exists", "[defer]",          ["script1"]);
+	t( "Attribute Exists", "[disabled]",       ["check1"]);
+	t( "Attribute Exists", "[formnovalidate]", ["form1"]);
+	t( "Attribute Exists", "[hidden]",         ["div1"]);
+	t( "Attribute Exists", "[indeterminate]",  []);
+	t( "Attribute Exists", "[ismap]",          ["img1"]);
+	t( "Attribute Exists", "[itemscope]",      ["div1"]);
+	// t( "Attribute Exists", "[loop]",           ["video1"]); // IE 6/7 cannot differentiate here. loop is also used on img, input, and marquee tags as well as video/audio. getAttributeNode unfortunately also retrieves the property value.
+	t( "Attribute Exists", "[multiple]",       ["select1"]);
+	t( "Attribute Exists", "[muted]",          ["audio1"]);
+	// t( "Attribute Exists", "[nohref]",         ["area1"]); // IE 6/7 keep this set to false regardless of presence. The attribute node is not retrievable.
+	t( "Attribute Exists", "[noresize]",       ["textarea1"]);
+	t( "Attribute Exists", "[noshade]",        ["hr1"]);
+	t( "Attribute Exists", "[nowrap]",         ["td1", "div1"]);
+	t( "Attribute Exists", "[novalidate]",     ["form1"]);
+	t( "Attribute Exists", "[open]",           ["details1"]);
+	t( "Attribute Exists", "[pubdate]",        ["article1"]);
+	t( "Attribute Exists", "[readonly]",       ["text1"]);
+	t( "Attribute Exists", "[required]",       ["text1"]);
+	t( "Attribute Exists", "[reversed]",       ["ol1"]);
+	t( "Attribute Exists", "[scoped]",         ["style1"]);
+	t( "Attribute Exists", "[seamless]",       ["iframe1"]);
+	t( "Attribute Exists", "[selected]",       ["option1"]);
+	t( "Attribute Exists", "[truespeed]",      ["marquee1"]);
+
+	// Enumerated attributes (these are not boolean content attributes)
+	jQuery.expandedEach = jQuery.each;
+	jQuery.expandedEach([ "draggable", "contenteditable", "aria-disabled" ], function( i, val ) {
+		t( "Enumerated attribute", "[" + val + "]", ["div1"]);
+	});
+	t( "Enumerated attribute", "[spellcheck]", ["span1"]);
+
+	// t( "tabindex selector does not retrieve all elements in IE6/7(#8473)", "form, [tabindex]", ["form1", "text1"] ); // sigh, FF12 QSA mistakenly includes video elements even though they have no tabindex attribute (see https://bugzilla.mozilla.org/show_bug.cgi?id=618737)
+	t( "Improperly named form elements do not interfere with form selections (#9570)", "form[name='formName']", ["form1"] );
+});
+
+testIframe("selector/sizzle_cache", "Sizzle cache collides with multiple Sizzles on a page", function( jQuery, window, document ) {
+	var $cached = window["$cached"];
+
+	expect(4);
+	notStrictEqual( jQuery, $cached, "Loaded two engines" );
+	deepEqual( $cached(".test a").get(), [ document.getElementById("collision") ], "Select collision anchor with first sizzle" );
+	equal( jQuery(".evil a").length, 0, "Select nothing with second sizzle" );
+	equal( jQuery(".evil a").length, 0, "Select nothing again with second sizzle" );
+});