lsd_rails 0.1

data/Packages/slick/SlickSpec/specs/dojo.js

@@ -0,0 +1,260 @@
+var specsDojo = function(context){
+	var should = '';
+	var doh = context.doh = global.doh = {};
+	
+	it('should exist', function(){
+		expect( context.SELECT ).toBeDefined();
+	});
+	
+	doh.is = function(expected, actual){
+		expect( actual ).toEqual( expected );
+	};
+	
+	doh.register = function(name, tests){
+		for (var i=0, test; test = tests[i]; i++){
+			if (!test) continue;
+			it(should + test, new Function(test));
+		}
+	};
+	
+	var dojo = context.dojo = global.dojo = {};
+	
+	dojo.query = function(selector, contextNode){
+		if (contextNode === undefined) contextNode = context.document;
+		return context.SELECT(dojo.byId(contextNode), selector);
+	};
+	
+	dojo.byId = function(id){
+		if (id.nodeType) return id;
+		return context.document.getElementById(id);
+	};
+
+	doh.register("t", 
+		[
+			// "doh.t(false, 'howdy!')",
+			// "doh.f(true, 'howdy!')",
+			// "doh.e(Error, window, function(){ throw new Error(); })",
+
+			// basic sanity checks
+			"doh.is(4, (dojo.query('h3')).length);",
+			"doh.is(1, (dojo.query('h1:first-child')).length);",
+			"doh.is(2, (dojo.query('h3:first-child')).length);",
+			"doh.is(1, (dojo.query('#t')).length);",
+			"doh.is(1, (dojo.query('#bug')).length);",
+			"doh.is(4, (dojo.query('#t h3')).length);",
+			"doh.is(1, (dojo.query('div#t')).length);",
+			"doh.is(4, (dojo.query('div#t h3')).length);",
+			"doh.is(0, (dojo.query('span#t')).length);",
+			"doh.is(0, (dojo.query('.bogus')).length);",
+			"doh.is(0, (dojo.query('.bogus', dojo.byId('container'))).length);",
+			"doh.is(0, (dojo.query('#bogus')).length);",
+			"doh.is(0, (dojo.query('#bogus', dojo.byId('container'))).length);",
+			"doh.is(1, (dojo.query('#t div > h3')).length);",
+			"doh.is(2, (dojo.query('.foo')).length);",
+			"doh.is(1, (dojo.query('.foo.bar')).length);",
+			"doh.is(2, (dojo.query('.baz')).length);",
+			"doh.is(3, (dojo.query('#t > h3')).length);",
+
+			"doh.is(2, (dojo.query('#baz,#foo,#t')).length);",
+
+			// classnames aren't case sensitive, only attribute selectors and xml tagnames, this spec is invalid
+			// "doh.is(1, dojo.query('.fooBar').length);",
+			"doh.is(1, dojo.query('[class~=foobar]').length);",
+			"doh.is(1, dojo.query('[class~=fooBar]').length);",
+
+			// syntactic equivalents
+			"doh.is(12, (dojo.query('#t > *')).length);",
+			"doh.is(12, (dojo.query('#t >')).length);",
+			"doh.is(3, (dojo.query('.foo >')).length);",
+			"doh.is(3, (dojo.query('.foo > *')).length);",
+
+			// with a root, by ID
+			"doh.is(3, (dojo.query('> *', 'container')).length);",
+			"doh.is(3, (dojo.query('> h3', 't')).length);",
+
+			// compound queries
+			"doh.is(2, (dojo.query('.foo, .bar')).length);",
+			"doh.is(2, (dojo.query('.foo,.bar')).length);",
+
+			// multiple class attribute
+			"doh.is(1, (dojo.query('.foo.bar')).length);",
+			"doh.is(2, (dojo.query('.foo')).length);",
+			"doh.is(2, (dojo.query('.baz')).length);",
+
+			// case sensitivity
+			"doh.is(1, (dojo.query('span.baz')).length);",
+			"doh.is(1, (dojo.query('sPaN.baz')).length);",
+			"doh.is(1, (dojo.query('SPAN.baz')).length);",
+			"doh.is(1, (dojo.query('[class = \"foo bar\"]')).length);",
+			"doh.is(2, (dojo.query('[foo~=\"bar\"]')).length);",
+			"doh.is(2, (dojo.query('[ foo ~= \"bar\" ]')).length);",
+
+			// "t.is(0, (dojo.query('[ foo ~= \"\\'bar\\'\" ]')).length);",
+			"doh.is(3, (dojo.query('[foo]')).length);",
+			"doh.is(1, (dojo.query('[foo$=\"thud\"]')).length);",
+			"doh.is(1, (dojo.query('[foo$=thud]')).length);",
+			"doh.is(1, (dojo.query('[foo$=\"thudish\"]')).length);",
+			"doh.is(1, (dojo.query('#t [foo$=thud]')).length);",
+			"doh.is(1, (dojo.query('#t [ title $= thud ]')).length);",
+			"doh.is(0, (dojo.query('#t span[ title $= thud ]')).length);",
+			// The mock source has two elements that match
+			// "doh.is(1, (dojo.query('[foo|=\"bar\"]')).length);",
+			"doh.is(1, (dojo.query('[foo|=\"bar-baz\"]')).length);",
+			"doh.is(0, (dojo.query('[foo|=\"baz\"]')).length);",
+			"doh.is(dojo.byId('_foo'), dojo.query('.foo:nth-child(2)')[0]);",
+			"doh.is(dojo.query('style')[0], dojo.query(':nth-child(2)')[0]);",
+
+			// descendant selectors
+			"doh.is(3, dojo.query('>', 'container').length);",
+			"doh.is(3, dojo.query('> *', 'container').length);",
+			"doh.is(2, dojo.query('> [qux]', 'container').length);",
+			"doh.is('child1', dojo.query('> [qux]', 'container')[0].id);",
+			"doh.is('child3', dojo.query('> [qux]', 'container')[1].id);",
+			"doh.is(3, dojo.query('>', 'container').length);",
+			"doh.is(3, dojo.query('> *', 'container').length);",
+			"doh.is('passed', dojo.query('#bug')[0].value);",
+
+			// bug 9071
+			"doh.is(2, (dojo.query('a', 't4')).length);",
+			"doh.is(2, (dojo.query('p a', 't4')).length);",
+			"doh.is(2, (dojo.query('div p', 't4')).length);",
+			"doh.is(2, (dojo.query('div p a', 't4')).length);",
+			"doh.is(2, (dojo.query('.subA', 't4')).length);",
+			"doh.is(2, (dojo.query('.subP .subA', 't4')).length);",
+			"doh.is(2, (dojo.query('.subDiv .subP', 't4')).length);",
+			"doh.is(2, (dojo.query('.subDiv .subP .subA', 't4')).length);",
+
+
+			// failed scope arg
+			"doh.is(0, (dojo.query('*', 'thinger')).length);",
+			"doh.is(0, (dojo.query('div#foo').length));",
+
+			// sibling selectors
+			"doh.is(1, dojo.query('+', 'container').length);",
+			"doh.is(3, dojo.query('~', 'container').length);",
+			"doh.is(1, (dojo.query('.foo + span')).length);",
+			"doh.is(4, (dojo.query('.foo ~ span')).length);",
+			"doh.is(1, (dojo.query('#foo ~ *')).length);",
+			"doh.is(1, (dojo.query('#foo ~')).length);",
+
+			// sub-selector parsing
+			"doh.is(1, dojo.query('#t span.foo:not(span:first-child)').length);",
+			"doh.is(1, dojo.query('#t span.foo:not(:first-child)').length);",
+
+			// nth-child tests
+			"doh.is(2, dojo.query('#t > h3:nth-child(odd)').length);",
+			"doh.is(3, dojo.query('#t h3:nth-child(odd)').length);",
+			"doh.is(3, dojo.query('#t h3:nth-child(2n+1)').length);",
+			"doh.is(1, dojo.query('#t h3:nth-child(even)').length);",
+			"doh.is(1, dojo.query('#t h3:nth-child(2n)').length);",
+			"doh.is(1, dojo.query('#t h3:nth-child(2n+3)').length);",
+			"doh.is(2, dojo.query('#t h3:nth-child(1)').length);",
+			"doh.is(1, dojo.query('#t > h3:nth-child(1)').length);",
+			"doh.is(3, dojo.query('#t :nth-child(3)').length);",
+			"doh.is(0, dojo.query('#t > div:nth-child(1)').length);",
+			"doh.is(7, dojo.query('#t span').length);",
+			"doh.is(3, dojo.query('#t > *:nth-child(n+10)').length);",
+			"doh.is(1, dojo.query('#t > *:nth-child(n+12)').length);",
+			"doh.is(10, dojo.query('#t > *:nth-child(-n+10)').length);",
+			(!global.disableNegNth) ? "doh.is(5, dojo.query('#t > *:nth-child(-2n+10)').length);" : '',
+			"doh.is(6, dojo.query('#t > *:nth-child(2n+2)').length);",
+			"doh.is(5, dojo.query('#t > *:nth-child(2n+4)').length);",
+			"doh.is(5, dojo.query('#t > *:nth-child(2n+4)').length);",
+			"doh.is(12, dojo.query('#t > *:nth-child(n-5)').length);",
+			"doh.is(6, dojo.query('#t > *:nth-child(2n-5)').length);",
+			
+			// :checked pseudo-selector
+			"doh.is(2, dojo.query('#t2 > :checked').length);",
+			"doh.is(dojo.byId('checkbox2'), dojo.query('#t2 > input[type=checkbox]:checked')[0]);",
+			"doh.is(dojo.byId('radio2'), dojo.query('#t2 > input[type=radio]:checked')[0]);",
+			// this failure should be ignored for now, this behavior is strange
+			// and some browsers dont implement this on theyres QSA 
+			"doh.is(2, dojo.query('#t2select option:checked').length);",
+
+			// cross-document queries
+/*
+			{
+
+				name: "crossDocumentQuery",
+				setUp: function(){
+					dojo.require("dojo.io.iframe");
+					this.t3 = window.frames["t3"];
+					this.doc = dojo.io.iframe.doc(t3);
+					this.doc.open();
+					this.doc.write([
+						"<html><head>",
+						"<title>inner document</title>",
+						"</head>",
+						"<body>",
+						"<div id='st1'><h3>h3 <span>span <span> inner <span>inner-inner</span></span></span> endh3 </h3></div>",
+						"</body>",
+						"</html>"
+					].join(""));
+				},
+				runTest: function(){
+					doh.is(1, dojo.query('h3', dojo.byId("st1", this.doc)).length);
+					// use a long query to force a test of the XPath system on FF. see bug #7075
+					doh.is(1, dojo.query('h3 > span > span > span', dojo.byId("st1", this.doc)).length);
+					doh.is(1, dojo.query('h3 > span > span > span', this.doc.body.firstChild).length);
+				}
+			},
+*/
+
+			// :empty pseudo-selector
+			"doh.is(4, dojo.query('#t > span:empty').length);",
+			"doh.is(6, dojo.query('#t span:empty').length);",
+			"doh.is(0, dojo.query('h3 span:empty').length);",
+			"doh.is(1, dojo.query('h3 :not(:empty)').length);"
+
+/*
+			// escaping of ":" chars inside an ID
+			function silly_IDs1(){
+				doh.t(document.getElementById("silly:id::with:colons"));
+				doh.is(1, dojo.query("#silly\\:id\\:\\:with\\:colons").length);
+			},
+			function NodeList_identity(){
+				var foo = new dojo.NodeList([dojo.byId("container")]);
+				doh.is(foo, dojo.query(foo));
+			},
+			function xml(){
+				var doc = createDocument([
+					"<ResultSet>",
+						"<Result>One</Result>",
+						"<RESULT>Two</RESULT>",
+						"<result>Three</result>",
+						"<result>Four</result>",
+					"</ResultSet>"
+				].join("")
+				);
+				var de = doc.documentElement;
+
+				doh.is(2, dojo.query("result", de).length, "all lower");
+				doh.is(1, dojo.query("Result", de).length, "mixed case");
+				doh.is(1, dojo.query("RESULT", de).length, "all upper");
+				doh.is(0, dojo.query("resulT", de).length, "no match");
+				doh.is(0, dojo.query("rEsulT", de).length, "no match");
+			},
+			function xml_attrs(){
+				var doc = createDocument([
+					"<ResultSet>",
+						"<RESULT thinger='blah'>Two</RESULT>",
+						"<RESULT thinger='gadzooks'>Two</RESULT>",
+					"</ResultSet>"
+				].join(""));
+				var de = doc.documentElement;
+
+				doh.is(2, dojo.query("RESULT", de).length, "result elements");
+				doh.is(0, dojo.query("RESULT[THINGER]", de).length, "result elements with attrs (wrong)");
+				doh.is(2, dojo.query("RESULT[thinger]", de).length, "result elements with attrs");
+				doh.is(1, dojo.query("RESULT[thinger=blah]", de).length, "result elements with attr value");
+			},
+			function sort(){
+				var i = dojo.query("div");
+				// smoke test
+				i.sort(function(a,b){ return 1; })
+			}
+*/
+		]
+	);
+
+};

data/Packages/slick/SlickSpec/specs/engine_bugs.js

@@ -0,0 +1,388 @@
+var specsSelectorEngineBugs = function(context){
+	
+	describe('Bugs', function(){
+		var rootElement;
+		var testNode;
+		var isXML = !isHTML(context.document);//context.isXML(context.document);
+		
+		var setup = function(){
+			testNode = context.document.createElement('div');
+			rootElement = context.document.getElementsByTagName('body')[0];
+			rootElement = rootElement || context.document.documentElement;
+			if (rootElement)
+				rootElement.appendChild(testNode);
+		}; 
+		beforeEach(setup);
+		
+		var teardown = function(){
+			testNode && testNode.parentNode && testNode.parentNode.removeChild(testNode);
+			testNode = null;
+		};
+		afterEach(teardown);
+		
+		it('document should have a documentElement', function(){
+			expect( context.document.documentElement ).toBeDefined();
+			expect( context.document.documentElement.childNodes.length ).toBeDefined();
+		});
+	
+		it('document should have nodes', function(){
+			expect( context.document.getElementsByTagName('*').length ).not.toEqual( 0 );
+		});
+	
+		it('should not return not-nodes', function(){
+			var results = context.SELECT(context.document,'*');
+		
+			for (var i=0; i < results.length; i++) {
+				expect( results[i] ).toBeDefined();
+				expect( results[i].nodeName ).toBeDefined();
+			}
+		});
+	
+		it('should not return close nodes', function(){
+			var results = context.SELECT(context.document,'*');
+		
+			for (var i=0; i < results.length; i++) {
+				expect( results[i].nodeName ).not.toMatch(/^\//);
+			}
+		});
+	
+		var starIncludesClosedNodes = !!$try(function(){
+			return context.document.createElement('/foo').nodeName.substring(0, 1) == '/';
+		});
+	
+		if (starIncludesClosedNodes && context.document && context.document.querySelectorAll && !global.cannotDisableQSA)
+		it('should not return closed nodes with QSA', function(){
+			teardown();setup();
+			testNode.innerHTML = 'foo</foo>';
+			var results = context.SELECT(testNode,'*');
+		
+			for (var i=0; i < results.length; i++) {
+				expect( results[i].nodeName ).toMatch(/^\w+$/);
+			}
+		});
+	
+		if (starIncludesClosedNodes)
+		it('should not return closed nodes ' + (!global.cannotDisableQSA ? '` without QSA' : ''), function(){
+			teardown();setup();
+			var tmpNode;
+			tmpNode = context.document.createElement('/foo');testNode.appendChild(tmpNode);
+			expect( tmpNode.nodeName ).toEqual('/foo');
+		
+			context.SELECT.disableQSA = true;
+			var results = context.SELECT(testNode,'*');
+			context.SELECT.disableQSA = false;
+		
+			for (var i=0; i < results.length; i++) {
+				expect( results[i].nodeName ).toMatch(/^\w+$/);
+			}
+		});
+	
+		//it('should not return closed nodes2', function(){
+		//testNode.innerHTML = '<foo>foo</foo> <bar>bar</bar> <baz>baz</baz>';
+		//
+		//var results = context.SELECT(testNode, '*');
+		//	expect( results.length ).toEqual(3);
+		//});
+	
+		it('should not return comment nodes', function(){
+			var results = context.SELECT(context.document,'*');
+		
+			for (var i=0; i < results.length; i++) {
+				expect( results[i].nodeName ).not.toMatch(/^#/);
+			}
+		});
+	
+		it('should return an element with the second class defined to it', function(){
+			teardown();setup();
+			
+			var className = 'class1 class2';
+			var tmpNode;
+			tmpNode = context.document.createElement('span');
+			tmpNode.setAttribute('class',className);
+			tmpNode.setAttribute('className',className);
+			testNode.appendChild(tmpNode);
+		
+			// expect( tmpNode.getAttribute('class') ).toEqual( className );
+			// expect( testNode.childNodes.length ).toEqual( 1 );
+			// expect( testNode.firstChild ).toEqual( tmpNode );
+			// 
+			// expect( testNode.className || tmpNode.getAttribute('class') ).toMatch( new RegExp('(^|\\s)' + Slick.parse.escapeRegExp(className.split(' ')[0]) + '(\\s|$)') );
+			// expect( testNode.className || tmpNode.getAttribute('class') ).toMatch( new RegExp('(^|\\s)' + Slick.parse.escapeRegExp(className.split(' ')[1]) + '(\\s|$)') );
+		
+			// if (!tmpNode.className){
+			// 	for (var mockName in global.mocks) {
+			// 		if (context == global.mocks[mockName]) alert(mockName);
+			// 	}
+			// }
+		
+			// expect( tmpNode.className ).toMatch( new RegExp('(^|\\s)' + Slick.parse.escapeRegExp(className.split(' ')[0]) + '(\\s|$)') );
+			// expect( tmpNode.className ).toMatch( new RegExp('(^|\\s)' + Slick.parse.escapeRegExp(className.split(' ')[1]) + '(\\s|$)') );
+		
+			// if (!test) test = function(value){
+			// 	return value && regexp.test(value);
+			// }
+			// new RegExp('(^|\\s)' + Slick.parse.escapeRegExp(className) + '(\\s|$)');
+		
+			var results = context.SELECT(testNode, '.class2');
+			expect( results[0] ).toEqual(tmpNode);
+		});
+	
+		it('should return the elements with passed class', function(){
+			teardown();setup();
+			var results;
+		
+			var tmpNode1; tmpNode1 = context.document.createElement('span'); tmpNode1.setAttribute('class','b'); tmpNode1.setAttribute('className','b'); testNode.appendChild(tmpNode1);
+			var tmpNode2; tmpNode2 = context.document.createElement('span'); tmpNode2.setAttribute('class','b'); tmpNode2.setAttribute('className','b'); testNode.appendChild(tmpNode2);
+		
+		
+			expect( context.SELECT(testNode, '.b', []).length ).toEqual(2);
+			expect( context.SELECT(testNode, '.f', []).length ).toEqual(0);
+			expect( context.SELECT(testNode, '[class|=b]', []).length ).toEqual(2);
+			expect( context.SELECT(testNode, '[class=b]', []).length ).toEqual(2);
+		
+			expect( context.SELECT(testNode, '.b', []).length ).not.toEqual(0);
+			expect( context.SELECT(testNode, '.f', []).length ).toEqual(0);
+		
+			results = context.SELECT(testNode, '.b');
+			expect( results.length ).toEqual(2);
+		
+			expect( tmpNode1.getAttribute('class') ).toEqual('b');
+		
+			tmpNode1.removeAttribute('class');
+			tmpNode1.removeAttribute('className');
+			expect( tmpNode1.getAttribute('class') ).toBeNull();
+		
+			tmpNode1.setAttribute('class','f');
+			tmpNode1.setAttribute('className','f');
+		
+			expect( tmpNode1.getAttribute('class') ).toEqual('f');
+			expect( context.SELECT(tmpNode1, '.b', []).length ).toEqual(0);
+			expect( context.SELECT(testNode, '.f', [])[0] ).toEqual(tmpNode1);
+		
+			expect( context.SELECT(testNode, '.b', []).length ).toEqual(1);
+			expect( context.SELECT(testNode, '.f', []).length ).toEqual(1);
+		
+			results = context.SELECT(testNode, '.b');
+			expect( results.length ).toEqual(1);
+		
+			tmpNode1.removeAttribute('class');
+			tmpNode1.removeAttribute('className');
+			tmpNode1.setAttribute('class','b');
+			tmpNode1.setAttribute('className','b');
+		
+			results = context.SELECT(testNode, '.b');
+			expect( results.length ).toEqual(2);
+		});
+	
+		it('should return the element with passed id even if the context is not in the DOM', function(){
+			teardown();setup();
+			testNode.parentNode.removeChild(testNode);
+			tmpNode = context.document.createElement('input');tmpNode.setAttribute('id', 'someuniqueid');tmpNode.setAttribute('type','text');testNode.appendChild(tmpNode);
+		
+			var results = context.SELECT(testNode, '#someuniqueid');
+			expect( results.length ).toEqual(1);
+			expect( results[0].tagName ).toMatch(/INPUT/i);
+			expect( results[0].getAttribute('type') ).toEqual('text');
+		});
+	
+	});
+};
+
+
+var specsBrowserBugsFixed = function(context){
+	
+	describe('Bugs Fixed', function(){
+
+		var rootElement;
+		var testNode, tmpNode, tmpNode1, tmpNode2, tmpNode3, tmpNode4, tmpNode5, tmpNode6, tmpNode7, tmpNode8, tmpNode9;
+		var isXML = !isHTML(context.document);
+		var results, resultsArray;
+		var setup = function(){
+			testNode = context.document.createElement('div');
+			rootElement = context.document.getElementsByTagName('body')[0];
+			rootElement = rootElement || context.document.documentElement;
+			rootElement.appendChild(testNode);
+		};
+		var teardown = function(){
+			testNode && testNode.parentNode && testNode.parentNode.removeChild(testNode);
+			testNode = null;
+		};
+
+		describe('SELECT [name]', function(){
+		
+			beforeEach(setup);
+			afterEach(teardown);
+	
+			it('Should match name attribute', function(){
+				teardown();setup();
+		
+				tmpNode2 = context.document.createElement('input');tmpNode2.setAttribute('id',  'getelementsbyname');tmpNode2.setAttribute('type','password');testNode.appendChild(tmpNode2);
+				tmpNode1 = context.document.createElement('input');tmpNode1.setAttribute('name','getelementsbyname');tmpNode1.setAttribute('type','text');testNode.appendChild(tmpNode1);
+		
+				results = context.SELECT(testNode,'[name=getelementsbyname]',[]);
+				expect( results ).toContain(tmpNode1);
+		
+				teardown();setup();
+		
+				tmpNode1 = context.document.createElement('input');tmpNode1.setAttribute('name','getelementsbyname');tmpNode1.setAttribute('type','text');testNode.appendChild(tmpNode1);
+				tmpNode2 = context.document.createElement('input');tmpNode2.setAttribute('id',  'getelementsbyname');tmpNode2.setAttribute('type','password');testNode.appendChild(tmpNode2);
+		
+				results = context.SELECT(testNode,'[name=getelementsbyname]',[]);
+				expect( results ).toContain(tmpNode1);
+			});
+	
+			it('Should NOT match id attribute', function(){
+				teardown();setup();
+		
+				tmpNode2 = context.document.createElement('input');tmpNode2.setAttribute('id',  'getelementsbyname');tmpNode2.setAttribute('type','password');testNode.appendChild(tmpNode2);
+				tmpNode1 = context.document.createElement('input');tmpNode1.setAttribute('name','getelementsbyname');tmpNode1.setAttribute('type','text');testNode.appendChild(tmpNode1);
+		
+				results = context.SELECT(testNode,'[name=getelementsbyname]');
+				for (var i=0; i < results.length; i++) {
+					// expect( results[i] ).not.toEqual( tmpNode2 );
+					expect( results[i] == tmpNode2 ).toEqual(false);
+				}
+		
+				teardown();setup();
+		
+				tmpNode1 = context.document.createElement('input');tmpNode1.setAttribute('name','getelementsbyname');tmpNode1.setAttribute('type','text');testNode.appendChild(tmpNode1);
+				tmpNode2 = context.document.createElement('input');tmpNode2.setAttribute('id',  'getelementsbyname');tmpNode2.setAttribute('type','password');testNode.appendChild(tmpNode2);
+		
+				results = context.SELECT(testNode,'[name=getelementsbyname]');
+				for (var i=0; i < results.length; i++) {
+					// expect( results[i] ).not.toEqual( tmpNode2 );
+					expect( results[i] == tmpNode2 ).toEqual(false);
+				}
+			});
+	
+		});
+
+		describe('SELECT #', function(){
+	
+			beforeEach(setup);
+			afterEach(teardown);
+	
+			it('Should NOT match name attribute', function(){
+				teardown();setup();
+		
+				tmpNode1 = context.document.createElement('input');tmpNode1.setAttribute('name','getelementbyid');tmpNode1.setAttribute('type','text');testNode.appendChild(tmpNode1);
+				tmpNode2 = context.document.createElement('input');tmpNode2.setAttribute('id',  'getelementbyid');tmpNode2.setAttribute('type','password');testNode.appendChild(tmpNode2);
+		
+				results = context.SELECT(testNode,'#getelementbyid',[]);
+				expect( results[0] == tmpNode1).toEqual(false);
+				// expect( results ).not.toEqual([tmpNode1]);
+				// expect( results[0] ).not.toEqual(tmpNode1);
+			});
+	
+			if( !isXML )
+			it('Should NOT match name attribute, using innerHTML', function(){
+				teardown();setup();
+		
+				testNode.innerHTML = '<input name="getelementbyid" type="text" /><input id="getelementbyid" type="password" />';
+				tmpNode1 = testNode.firstChild;
+				tmpNode2 = testNode.lastChild;
+		
+				results = context.SELECT(testNode,'#getelementbyid',[]);
+				expect( results[0] == tmpNode1).toEqual(false);
+			});
+	
+			it('Should match id attribute, even when another element has that [name]', function(){
+				teardown();setup();
+		
+				tmpNode1 = context.document.createElement('input');tmpNode1.setAttribute('name','getelementbyid');tmpNode1.setAttribute('type','text');testNode.appendChild(tmpNode1);
+				tmpNode2 = context.document.createElement('input');tmpNode2.setAttribute('id',  'getelementbyid');tmpNode2.setAttribute('type','password');testNode.appendChild(tmpNode2);
+				tmpNode3 = context.document.createElement('input');tmpNode3.setAttribute('name','getelementbyid');tmpNode3.setAttribute('type','text');testNode.appendChild(tmpNode3);
+		
+				results = context.SELECT(testNode,'#getelementbyid',[]);
+				// expect( results ).toEqual([tmpNode2]);
+				// expect( results[0] ).toEqual(tmpNode2);
+				expect( results[0] == tmpNode2).toEqual(true);
+			});
+	
+			if( !isXML )
+			it('Should match id attribute, even when another element has that [name], using innerHTML', function(){
+				teardown();setup();
+		
+				testNode.innerHTML = '<input name="getelementbyid" type="text" /><input id="getelementbyid" type="password" /><input name="getelementbyid" type="text" />';
+				tmpNode1 = testNode.childNodes[0];
+				tmpNode2 = testNode.childNodes[1];
+				tmpNode3 = testNode.childNodes[2];
+		
+				results = context.SELECT(testNode,'#getelementbyid',[]);
+				// expect( results ).toEqual([tmpNode2]);
+				// expect( results[0] ).toEqual(tmpNode2);
+				expect( results[0] == tmpNode2).toEqual(true);
+			});
+
+			if( !isXML )
+			it('Should get just the first matched element with passed id, using innerHTML', function(){
+				teardown();setup();
+		
+				testNode.innerHTML = '<input name="getelementbyid" type="text" /><input id="getelementbyid" type="password" /><input name="getelementbyid" type="text" /><input id="getelementbyid" type="text" />';
+				tmpNode1 = testNode.childNodes[0];
+				tmpNode2 = testNode.childNodes[1];
+				tmpNode3 = testNode.childNodes[2];
+				tmpNode4 = testNode.childNodes[3];
+		
+				results = context.SELECT(testNode,'#getelementbyid',[]);
+				// expect( results ).toEqual([tmpNode2]);
+				// expect( results[0] ).toEqual(tmpNode2);
+				expect( results[0] == tmpNode2 ).toEqual(true);
+				expect( results.length ).toEqual(1);
+			});
+	
+			if( !isXML )
+			it('Should get just the first matched element with passed id, using innerHTML, changing nodes orders', function(){
+				teardown();setup();
+		
+				testNode.innerHTML = '<input id="getelementbyid" type="password" /><input name="getelementbyid" type="text" /><input name="getelementbyid" type="text" /><input id="getelementbyid" type="text" />';
+				tmpNode1 = testNode.childNodes[0];
+				tmpNode2 = testNode.childNodes[1];
+				tmpNode3 = testNode.childNodes[2];
+				tmpNode4 = testNode.childNodes[3];
+		
+				results = context.SELECT(testNode,'#getelementbyid',[]);
+				// expect( results ).toEqual([tmpNode2]);
+				// expect( results[0] ).toEqual(tmpNode2);
+				expect( results[0] == tmpNode1 ).toEqual(true);
+				expect( results.length ).toEqual(1);
+			});
+	
+		});
+
+		describe('SELECT :selected', function(){
+	
+			beforeEach(setup);
+			afterEach(teardown);
+	
+			if( !isXML )
+			it('Should match the selected option', function(){
+				teardown();setup();
+		
+				testNode.innerHTML = '<select><option value="1">opt1</option><option value="2">opt2</option></select>';
+				tmpNode1 = testNode.firstChild;
+				tmpNode2 = tmpNode1.firstChild;
+				tmpNode3 = tmpNode1.lastChild;
+		
+				results = context.SELECT(testNode, ':selected');
+				expect(results.length).toEqual(1);
+				expect(results[0] === tmpNode2).toEqual(true);
+			});
+	
+			if( !isXML )
+			it('Should not match the first element from a multiple select', function(){
+				teardown();setup();
+		
+				testNode.innerHTML = '<select multiple="multiple"><option value="1">opt1</option><option value="2" selected="selected">opt2</option></select>';
+				tmpNode1 = testNode.firstChild;
+				tmpNode2 = tmpNode1.firstChild;
+				tmpNode3 = tmpNode1.lastChild;
+		
+				results = context.SELECT(testNode, ':selected');
+				expect(results.length).toEqual(1);
+				expect(results[0] === tmpNode3).toEqual(true);
+			});
+
+		});
+	});
+};