diff --git a/tests/TODO b/tests/TODO
index 4f66fa8..30ef027 100644
--- a/tests/TODO
+++ b/tests/TODO
@@ -1,10 +1,6 @@
 This file lists tests that need to be implemented or expanded. See ticket #3121
 for changes related to things listed here.

-Tests to add:
--------------
-	* add tests for dojo.place()
-
 Tests to improve:
 -----------------
 	* NodeList isn't testing several of its public methods (place, orphan, adopt, etc.)
diff --git a/tests/_base/html.html b/tests/_base/html.html
index 02ce9ad..d774bc3 100644
--- a/tests/_base/html.html
+++ b/tests/_base/html.html
@@ -43,7 +43,7 @@

 				doh.register("t",
 					[
-						"doh.is(null, dojo.byId('nonExistantId'));",
+						"doh.is(null, dojo.byId('nonExistentId'));",
 						"doh.is(null, dojo.byId(null));",
 						"doh.is(null, dojo.byId(''));",
 						"doh.is(undefined, dojo.byId(undefined));",
@@ -665,6 +665,19 @@
 							dojo.destroy(p);
 							doh.t(true, "no exception thrown");
 						}
+/*
+						// Make sure empty() doesn't disconnect grandchildren from children.
+						// Uncomment when http://bugs.dojotoolkit.org/ticket/16957 is fixed.
+						function emptyGrandchildren(){
+							var parent = dojo.byId("emptyParent"),
+								child = dojo.byId("emptyChild");
+
+							dojo.empty("emptyParent");
+
+							doh.f(!!parent.firstChild, "parent's children removed");
+							doh.t(!!child.firstChild, "child's children remain");
+						}
+*/
 					]
 				);

@@ -915,6 +928,13 @@
 			><param name="background" value="transparent"
 		/></object>

+		<!-- Test that empty doesn't disconnect grandchildren from children -->
+		<div id="emptyParent">
+			<div id="emptyChild">
+				<div id="emptyGrandchild">hello world</div>
+			</div>
+		</div>
+
 		<!-- IFRAME element to test destroy -->
 		<iframe id="iframeToDestroy" src="about:blank"
 			><span></span
diff --git a/tests/_base/i18nExhaustive.js b/tests/_base/i18nExhaustive.js
index 227d7c5..2119eae 100644
--- a/tests/_base/i18nExhaustive.js
+++ b/tests/_base/i18nExhaustive.js
@@ -4,6 +4,9 @@ define([
 	"require"
 ], function(dojo, doh, require){
 	var testParams = [
+		"sync,,src,./dojo,src,./i18n-test,legacy",
+		"sync,,src,./dojo,legacy-built,./built-i18n-test/152-build,legacy",
+		"sync,,src,./dojo,legacy-built-layer,./built-i18n-test/152-build-with-layers-and-preloads,legacy",
 		"sync,,src,./dojo,src,./i18n-test,amd",
 		"sync,,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
@@ -16,6 +19,10 @@ define([
 		"sync,,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
 		"sync,,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers-and-preloads/i18nTest,amd",
+				
+		"sync,ab,src,./dojo,src,./i18n-test,legacy",
+		"sync,ab,src,./dojo,legacy-built,./built-i18n-test/152-build,legacy",
+		"sync,ab,src,./dojo,legacy-built-layer,./built-i18n-test/152-build-with-layers-and-preloads,legacy",
 		"sync,ab,src,./dojo,src,./i18n-test,amd",
 		"sync,ab,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,ab,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
@@ -28,6 +35,10 @@ define([
 		"sync,ab,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,ab,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
 		"sync,ab,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers-and-preloads/i18nTest,amd",
+		
+		"sync,ab-cd,src,./dojo,src,./i18n-test,legacy",
+		"sync,ab-cd,src,./dojo,legacy-built,./built-i18n-test/152-build,legacy",
+		"sync,ab-cd,src,./dojo,legacy-built-layer,./built-i18n-test/152-build-with-layers-and-preloads,legacy",
 		"sync,ab-cd,src,./dojo,src,./i18n-test,amd",
 		"sync,ab-cd,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,ab-cd,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
@@ -40,6 +51,10 @@ define([
 		"sync,ab-cd,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,ab-cd,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
 		"sync,ab-cd,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers-and-preloads/i18nTest,amd",
+
+		"sync,ab-cd-ef,src,./dojo,src,./i18n-test,legacy",
+		"sync,ab-cd-ef,src,./dojo,legacy-built,./built-i18n-test/152-build,legacy",
+		"sync,ab-cd-ef,src,./dojo,legacy-built-layer,./built-i18n-test/152-build-with-layers-and-preloads,legacy",
 		"sync,ab-cd-ef,src,./dojo,src,./i18n-test,amd",
 		"sync,ab-cd-ef,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"sync,ab-cd-ef,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
@@ -64,6 +79,7 @@ define([
 		"async,,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"async,,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
 		"async,,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers-and-preloads/i18nTest,amd",
+		
 		"async,ab,src,./dojo,src,./i18n-test,amd",
 		"async,ab,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"async,ab,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
@@ -76,6 +92,7 @@ define([
 		"async,ab,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"async,ab,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
 		"async,ab,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers-and-preloads/i18nTest,amd",
+
 		"async,ab-cd,src,./dojo,src,./i18n-test,amd",
 		"async,ab-cd,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"async,ab-cd,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
@@ -88,6 +105,7 @@ define([
 		"async,ab-cd,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"async,ab-cd,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
 		"async,ab-cd,cdn,http://192.168.1.114/dev/dtk/built-i18n-test/cdn/dojo,built,./built-i18n-test/built-with-layers-and-preloads/i18nTest,amd",
+		
 		"async,ab-cd-ef,src,./dojo,src,./i18n-test,amd",
 		"async,ab-cd-ef,src,./dojo,built,./built-i18n-test/built/i18nTest,amd",
 		"async,ab-cd-ef,src,./dojo,built,./built-i18n-test/built-with-layers/i18nTest,amd",
diff --git a/tests/_base/loader/hostenv_webworkers.js b/tests/_base/loader/hostenv_webworkers.js
new file mode 100644
index 0000000..104f2cc
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers.js
@@ -0,0 +1,325 @@
+define([
+	"doh/main",
+	"dojo/has",
+	"dojo/sniff"
+], function(doh, has, sniff){
+	// summary:
+	//		Test the loading of Dojo in the WebWorker environment.
+
+	has.add("webworkers", (typeof Worker === 'function'));
+	if(has("webworkers")){
+		// Tests will still pass when workers not available but warning issued.
+
+		var fixtures = {
+			deferred: function(){
+				this.deferred = new doh.Deferred();
+			}
+		};
+
+		var tearDowns = {
+			killWorker: function(){
+				var self = this;
+				this.deferred.then(function(){
+					self.worker.terminate();
+				});
+
+			},
+			killBlobWorker: function(){
+				var self = this;
+				this.deferred.then(function(){
+					if(has("blobs") && has("convertObjectUrl")){
+						self.worker.terminate();
+						window.URL.revokeObjectURL(self.workerBlobURL);
+					}
+				});
+
+			}
+		};
+
+		function reflectConsole(message){
+			if(message.data.consoleType in console){
+				if(has("opera") && opera.postError){
+					opera.postError(message.data.consoleType.toUpperCase() + ": Platform does not support Blobs");
+				}else{
+					console[message.data.consoleType](message.data.value);
+				}
+			}else{
+				if(has("opera") && opera.postError){
+					opera.postError("ERROR: Could not reflect console message type: " + message.data.consoleType);
+				}else{
+					console.error("Could not reflect console message type: " + message.data.consoleType);
+				}
+			}
+		}
+
+		doh.register("tests._base.hostenv_webworkers", [{
+			name: "Loading Dojo core inside worker",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+				//		Test whether dojo can be loaded in the worker
+
+				var self = this;
+				this.worker = new Worker("../../dojo/tests/_base/loader/hostenv_webworkers/worker1.js");
+
+				this.worker.addEventListener("message", function (message){
+					if(message.data.type === "testResult"){
+						if(message.data.value){
+							self.deferred.resolve();
+						}else{
+							self.deferred.reject();
+						}
+					}else if(message.data.type === "console"){
+							reflectConsole(message);
+					}
+				}, false);
+
+				return this.deferred;
+			}
+		}, {
+			name: "Load a dojo script via require",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+				//		Test whether require works in the worker.
+
+				var self = this;
+				this.worker = new Worker("../../dojo/tests/_base/loader/hostenv_webworkers/worker2.js");
+
+				this.worker.addEventListener("message", function (message){
+					if(message.data.type === "testResult"){
+						if(message.data.value){
+							self.deferred.resolve();
+						}else{
+							self.deferred.reject();
+						}
+					}else if(message.data.type === "console"){
+						reflectConsole(message);
+					}
+				}, false);
+
+				return this.deferred;
+			}
+		}, {
+			name: "Load a dojo script via require in async mode",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+				//		Test whether require works in the worker when in async mode.
+
+				var self = this;
+				this.worker = new Worker("../../dojo/tests/_base/loader/hostenv_webworkers/worker3.js");
+
+				this.worker.addEventListener("message", function(message){
+					if(message.data.type === "testResult"){
+						if(message.data.value){
+							self.deferred.resolve();
+						}else{
+							self.deferred.reject();
+						}
+					}else if(message.data.type === "console"){
+						reflectConsole(message);
+					}
+				}, false);
+
+				return this.deferred;
+			}
+		}, {
+			name: "Load a dojo script via require in a subworker",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+				//		Test whether Dojo will load in a subworker.
+				// description:
+				// 		This is more complex as two workers are created. The first acts as a
+				// 		middleman between this function and the subworker.  Some browsers do not
+				// 		support subworkers at writing (eg. Chrome - see:
+				// 		https://code.google.com/p/chromium/issues/detail?id=31666 for current status).
+				// 		Test issues a warning if subworks not available but passes the test.
+
+				var self = this;
+				this.worker = new Worker("../../dojo/tests/_base/loader/hostenv_webworkers/worker4.js");
+
+				this.worker.addEventListener("message", function(message){
+					if(message.data.type === "testResult"){
+						if(message.data.value){
+							self.deferred.resolve();
+						}else{
+							self.deferred.reject();
+						}
+					}else if(message.data.type === "console"){
+						reflectConsole(message);
+					}
+				}, false);
+
+				return this.deferred;
+			}
+		}, {
+			name: "Test for loading in a blob worker",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killBlobWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+				//		Test for loading dojo and using require in a blob worker
+				has.add("blobs", (typeof Blob === 'function'));
+				has.add("convertObjectUrl", function(){
+					var URL = window.URL || window.webkitURL;
+					if(URL !== undefined){
+						return (typeof URL.createObjectURL === 'function');
+					}
+
+					return false;
+				});
+
+				if(has("blobs") && has("convertObjectUrl")){
+					function getBaseAbsoluteUrl(){
+						// summary:
+						// 		Blobs need absolute urls to be used within them as relative is relative
+						//		to blob://<object>.
+						// TODO:
+						//		Is there a better way of calculating the absolute url base path?
+
+						var baseUrl = require.rawConfig.baseUrl.split("/");
+						var absoluteUrl = location.pathname.split("/");
+						absoluteUrl.pop();
+						absoluteUrl.pop();
+						baseUrl.pop();
+
+						return location.protocol + "//" + location.host + absoluteUrl.join("/") + "/" + baseUrl.join("/") + "/";
+					}
+
+					var workerBlob = new Blob([
+						'var dojoConfig = {' +
+							'"baseUrl":"' + getBaseAbsoluteUrl() + '",' +
+							'"packages":[{"name":"dojo", "location":"dojo"}]' +
+						'};' +
+
+						'importScripts(' +
+							'dojoConfig.baseUrl+"dojo/dojo.js",' +
+							'dojoConfig.baseUrl+"dojo/tests/_base/loader/hostenv_webworkers/console.js"' +
+						');' +
+
+						'try{' +
+							'require(["dojo/tests/_base/loader/hostenv_webworkers/strings"], function(strings){' +
+								'this.postMessage({type:"testResult", "test":"require is working", "value":true});' +
+							'});' +
+						'}catch(e){' +
+							'this.postMessage({' +
+								'type:"testResult", "test":"require is working", "value":false' +
+						'});' +
+					'}'], {type: "text/javascript"});
+
+					var self = this;
+					var URL = window.URL || window.webkitURL;
+					self.workerBlobURL = URL.createObjectURL(workerBlob);
+
+					try{
+						this.worker = new Worker(self.workerBlobURL);
+						this.worker.addEventListener("message", function(message){
+							if(message.data.type === "testResult"){
+								if(message.data.value){
+									self.deferred.resolve();
+								}else{
+									self.deferred.reject();
+								}
+							}else if(message.data.type === "console"){
+								reflectConsole(message);
+							}
+						}, false);
+					}catch(e){
+						if(e.message.toLowerCase() === "securityerror"){
+							// IE does not support Webworkers from Blobs at present
+
+							console.warn("Blob workers are not supported");
+							self.deferred.resolve();
+						}else{
+							throw e;
+						}
+					}
+
+					return this.deferred;
+				}else{
+					if(window.opera){
+						opera.postError("WARN: Platform does not support Blobs");
+					}else{
+						console.log("Platform does not support Blobs");
+					}
+				}
+			}
+		}, {
+			name: "Test making a XHR request inside a worker using dojo/request",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+					//		Test using dojo/request in a worker
+				// description:
+				//		This is a more advanced test to ensure Dojo's implementation of
+				//		XHR works in the webworker.  It is also a general test of loading
+				//		components via require and then using them.
+
+				var self = this;
+				this.worker = new Worker("../../dojo/tests/_base/loader/hostenv_webworkers/worker5.js?v=4");
+
+				this.worker.addEventListener("message", function(message){
+					if(message.data.type === "testResult"){
+						if(message.data.value){
+							self.deferred.resolve();
+						}else{
+							self.deferred.reject();
+						}
+					}else if(message.data.type === "console"){
+						reflectConsole(message);
+					}
+				}, false);
+
+				return this.deferred;
+			}
+		}, {
+			name: "Test using dojo/on in a worker",
+			setUp: fixtures.deferred,
+			tearDown: tearDowns.killWorker,
+			timeout: 5000,
+			runTest: function(){
+				// summary:
+				//		Test using dojo/on in a worker.
+				// description:
+				//		Another advanced test to see if dojo/on works in workers where there is no DOM.
+				//		Test waits for the worker to request a message and then send one. Worker uses
+				//		dojo/on to listen for messages on the worker global.  It responds with a
+				//		pass for the test if it receives it correctly.
+
+				var self = this;
+				this.worker = new Worker("../../dojo/tests/_base/loader/hostenv_webworkers/worker6.js");
+
+				this.worker.addEventListener("message", function (message){
+					if(message.data.type === "testResult"){
+						if(message.data.value){
+							self.deferred.resolve();
+						}else{
+							self.deferred.reject();
+						}
+					}else if(message.data.type === "requestMessage"){
+						self.worker.postMessage({type: "gotMessage"})
+					}else if(message.data.type === "console"){
+						reflectConsole(message);
+					}
+				}, false);
+
+				return this.deferred;
+			}
+		}]);
+	}else{
+		console.warno("Platform does not support webworkers")
+	}
+});
diff --git a/tests/_base/loader/hostenv_webworkers/console.js b/tests/_base/loader/hostenv_webworkers/console.js
new file mode 100644
index 0000000..9103208
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/console.js
@@ -0,0 +1,30 @@
+// summary:
+//		Console polyfill for webworkers.
+// description:
+//		Webworkers do not have access to the console as of writing (except in Chrome).  This polyfills
+//		the console by passing messages back to the browser window for it to reflect to the console.
+//		This should make debugging of test failure a bit easier.
+
+if(!self.console){
+	console = {
+		_sendMessage: function(type, message){
+			self.postMessage({
+				type: "console",
+				consoleType: type,
+				value: message
+			});
+		},
+		log: function(message){
+			console._sendMessage("log", message);
+		},
+		error: function(message){
+			console._sendMessage("error", message);
+		},
+		warn: function(message){
+			console._sendMessage("warn", message);
+		},
+		info: function(message){
+			console._sendMessage("info", message);
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/_base/loader/hostenv_webworkers/strings.js b/tests/_base/loader/hostenv_webworkers/strings.js
new file mode 100644
index 0000000..53be273
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/strings.js
@@ -0,0 +1,5 @@
+define({
+	root: ({
+		foo: "bar"
+	})
+});
\ No newline at end of file
diff --git a/tests/_base/loader/hostenv_webworkers/worker1.js b/tests/_base/loader/hostenv_webworkers/worker1.js
new file mode 100644
index 0000000..6531e56
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker1.js
@@ -0,0 +1,30 @@
+// summary:
+//		Test whether Dojo will load inside the webworker.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+try{
+	importScripts("../../../../dojo.js", "console.js");
+
+	self.postMessage({
+		type: "testResult",
+		test: "dojo loaded",
+		value: true
+	});
+}catch(e){
+	self.postMessage({
+		type: "testResult",
+		test: "dojo loaded",
+		value: false
+	});
+}
+
+
+
+
+
diff --git a/tests/_base/loader/hostenv_webworkers/worker2.js b/tests/_base/loader/hostenv_webworkers/worker2.js
new file mode 100644
index 0000000..fef1de8
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker2.js
@@ -0,0 +1,27 @@
+// summary:
+//		Test whether the require function loads modules as it should.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+importScripts("../../../../dojo.js", "console.js");
+
+try{
+	require(["dojo/tests/_base/loader/hostenv_webworkers/strings"], function(strings){
+		self.postMessage({
+			type: "testResult",
+			test: "require is working",
+			value: true
+		});
+	});
+}catch(e){
+	self.postMessage({
+		type: "testResult",
+		test: "require is working",
+		value: false
+	});
+}
diff --git a/tests/_base/loader/hostenv_webworkers/worker3.js b/tests/_base/loader/hostenv_webworkers/worker3.js
new file mode 100644
index 0000000..1b94375
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker3.js
@@ -0,0 +1,28 @@
+// summary:
+//		Test whether the require function loads modules as it should in async mode.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	async: true,
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+importScripts("../../../../dojo.js", "console.js");
+
+try{
+	require(["dojo/tests/_base/loader/hostenv_webworkers/strings"], function(strings){
+		self.postMessage({
+			type: "testResult",
+			test: "require is working",
+			value: true
+		});
+	});
+}catch(e){
+	self.postMessage({
+		type: "testResult",
+		test: "require is working",
+		value: false
+	});
+}
diff --git a/tests/_base/loader/hostenv_webworkers/worker4-1.js b/tests/_base/loader/hostenv_webworkers/worker4-1.js
new file mode 100644
index 0000000..4aeb1ca
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker4-1.js
@@ -0,0 +1,28 @@
+// summary:
+//		Test whether subworkers work.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	async: true,
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+importScripts("../../../../dojo.js", "console.js");
+
+try{
+	require(["dojo/tests/_base/loader/hostenv_webworkers/strings"], function(strings){
+		self.postMessage({
+			type: "testResult",
+			test: "subworkers are working",
+			value: true
+		});
+	});
+}catch(e){
+	self.postMessage({
+		type: "testResult",
+		test: "subworkers are working",
+		value: false
+	});
+}
diff --git a/tests/_base/loader/hostenv_webworkers/worker4.js b/tests/_base/loader/hostenv_webworkers/worker4.js
new file mode 100644
index 0000000..a30813b
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker4.js
@@ -0,0 +1,38 @@
+// summary:
+//		Test subworkers, this is the worker in the middle, that spawns the subworker and passes
+//		messages between them.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	async: true,
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+importScripts("../../../../dojo.js", "console.js");
+
+require(["dojo/has"], function(has){
+	// Test for workers, currently chrome does not support subworkers.
+
+	has.add("webworkers", (typeof Worker === 'function'));
+	if(has("webworkers")){
+		var worker = new Worker("worker4-1.js");
+		worker.addEventListener("message", function(message){
+			self.postMessage(message.data);
+			worker.terminate();
+		}, false);
+	}else{
+		// Chrome does not support webworkers of writing this test
+		// (see: http://code.google.com/p/chromium/issues/detail?id=31666)
+
+		console.warn("Platform does not support subworkers");
+		self.postMessage({
+			type: "testResult",
+			test: "subworkers are working",
+			value: true
+		});
+	}
+});
+
+
diff --git a/tests/_base/loader/hostenv_webworkers/worker5.js b/tests/_base/loader/hostenv_webworkers/worker5.js
new file mode 100644
index 0000000..b40bfa7
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker5.js
@@ -0,0 +1,46 @@
+// summary:
+//		Test loading json via dojo/request in a worker.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	async: true,
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+importScripts("../../../../dojo.js", "console.js");
+
+try{
+	require(["dojo/request"], function(request){
+		request("../../../../tests/_base/loader/hostenv_webworkers/worker5.json", {
+			handleAs: "json"
+		}).then(function(data) {
+				if(data.foo && !data.bar){
+					self.postMessage({
+						type: "testResult",
+						test: data,
+						value: true
+					});
+				}else{
+					self.postMessage({
+						type: "testResult",
+						test: "require is working",
+						value: false
+					});
+				}
+			}, function(){
+				self.postMessage({
+					type: "testResult",
+					test: "request in a worker is working",
+					value: false
+				});
+			});
+	});
+}catch(e){
+	self.postMessage({
+		type: "testResult",
+		test: "request in a worker is working",
+		value: false
+	});
+}
diff --git a/tests/_base/loader/hostenv_webworkers/worker5.json b/tests/_base/loader/hostenv_webworkers/worker5.json
new file mode 100644
index 0000000..523b218
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker5.json
@@ -0,0 +1,4 @@
+{
+	"foo": true,
+	"bar": false
+}
\ No newline at end of file
diff --git a/tests/_base/loader/hostenv_webworkers/worker6.js b/tests/_base/loader/hostenv_webworkers/worker6.js
new file mode 100644
index 0000000..fd1eeab
--- /dev/null
+++ b/tests/_base/loader/hostenv_webworkers/worker6.js
@@ -0,0 +1,42 @@
+// summary:
+//		Test the use of dojo/on without access to dom in a webworker.
+
+var dojoConfig = {
+	baseUrl: "../../../../../",
+	async: true,
+	packages: [{
+		name: "dojo", location: "dojo"
+	}]
+};
+
+importScripts("../../../../dojo.js", "console.js");
+
+try{
+	require(["dojo/on"], function(on){
+		on(self, "message", function(message){
+			if(message.data.type === "gotMessage"){
+				self.postMessage({
+					type: "testResult",
+					test: "dojo/on in a worker is working",
+					value: true
+				});
+			}else{
+				self.postMessage({
+					type: "testResult",
+					test: "dojo/on in a worker is working",
+					value: false
+				});
+			}
+		});
+
+		self.postMessage({
+			type: "requestMessage"
+		});
+	});
+}catch(e){
+	self.postMessage({
+		type: "testResult",
+		test: "dojo/on in a worker is working",
+		value: false
+	});
+}
diff --git a/tests/dom-attr.html b/tests/dom-attr.html
new file mode 100644
index 0000000..cf127b3
--- /dev/null
+++ b/tests/dom-attr.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>testing dom-prop</title>
+		<script src="../dojo.js" data-dojo-config="isDebug:true"></script>
+		<script>
+			require(["dojo", "doh", "dojo/dom-attr", "dojo/dom", "dojo/domReady!"], function(dojo, doh, domAttr, dom){
+				doh.register([
+					{
+						name: "set / get value attribute",
+						runTest: function(t){
+							var test1 = dom.byId("test1"),
+								test2 = dom.byId("test2"),
+								value1 = domAttr.get(test1, "value"),
+								value2 = domAttr.get(test2, "value");
+
+							doh.is('6', value1);
+							doh.is('bar', value2);
+							
+							domAttr.set(test1, "value", "10");
+							domAttr.set(test2, "value", "foo");
+							
+							value1 = domAttr.get(test1, "value");
+							value2 = domAttr.get(test2, "value");
+							
+							doh.is('10', value1);
+							doh.is('foo', value2);
+							
+						}
+					}
+				]);
+
+				doh.run();
+			});
+		</script>
+	</head>
+	<body>
+		<meter id="test1" min="5" max="10" value="6"></meter>
+		<input id="test2" value="bar" />
+	</body>
+</html>
diff --git a/tests/dom-attr.js b/tests/dom-attr.js
new file mode 100644
index 0000000..c1fbd09
--- /dev/null
+++ b/tests/dom-attr.js
@@ -0,0 +1,3 @@
+define(["doh/main", "require"], function(doh, require){
+	doh.register("tests.dom-attr", require.toUrl("./dom-attr.html"), 30000);
+});
diff --git a/tests/dom-construct-place.html b/tests/dom-construct-place.html
new file mode 100644
index 0000000..3496639
--- /dev/null
+++ b/tests/dom-construct-place.html
@@ -0,0 +1,328 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>testing dom-contruct.place</title>
+		<script src="../dojo.js" data-dojo-config="isDebug:true"></script>
+		<script>
+			require(["doh", "dojo/dom-construct", "dojo/dom", "dojo/domReady!"], function(doh, construct, dom){
+
+				var TEST_POSITION = 2;
+				var lastHtml = "<div id='last'><h1>First</h1></div>";
+				var firstHtml = "<div id='first'><h1>First</h1></div>";
+				var beforeHtml = "<div id='before'></div>";
+				var afterHtml = "<div id='after'></div>";
+				var replaceHtml = "<div id='replace'></div>";
+				var onlyHtml = "<div id='only'><h1>first</h1></div>";
+
+				var posHtml = "<div id='pos'><div>first</div><div>second</div><div>last</div></div>";
+
+				var HTMLString = "<div id=\"test\">Test</div>";
+
+				var nodes = {};
+				var child;
+				var fragment;
+
+				function clearTarget() {
+					document.body.innerHTML = "";
+					child = construct.toDom(HTMLString);
+					nodes.last = construct.toDom(lastHtml);
+					nodes.first = construct.toDom(firstHtml);
+					nodes.before = construct.toDom(beforeHtml);
+					nodes.after = construct.toDom(afterHtml);
+					nodes.replace = construct.toDom(replaceHtml);
+					nodes.only = construct.toDom(onlyHtml);
+					nodes.pos = construct.toDom(posHtml);
+					document.body.appendChild(nodes.last);
+					document.body.appendChild(nodes.first);
+					document.body.appendChild(nodes.before);
+					document.body.appendChild(nodes.after);
+					document.body.appendChild(nodes.replace);
+					document.body.appendChild(nodes.only);
+					document.body.appendChild(nodes.pos);
+					fragment = document.createDocumentFragment();
+					fragment.appendChild(document.createElement("div"));
+					fragment.appendChild(document.createElement("div"));
+					fragment.appendChild(document.createElement("div"));
+				}
+
+				function elementsEqual(elementA, elementB) {
+					return elementA.id === elementB.id &&
+						elementA.tagName === elementB.tagName &&
+						elementA.innerHTML === elementB.innerHTML;
+				}
+
+				doh.register([
+					{
+						setUp: clearTarget,
+						name: "last - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.last);
+							doh.assertTrue(elementsEqual(child, nodes.last.lastChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "last - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "last");
+							doh.assertTrue(elementsEqual(child, nodes.last.lastChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "last - place html string with fragment reference",
+						runTest: function(t){
+							construct.place(HTMLString, fragment);
+							doh.assertTrue(elementsEqual(child, fragment.lastChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "last - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.last);
+							doh.assertEqual(child, nodes.last.lastChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "last - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "last");
+							doh.assertEqual(child, nodes.last.lastChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "last - place node with fragment reference",
+						runTest: function(t){
+							construct.place(child, fragment);
+							doh.assertEqual(child, fragment.lastChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "first - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.first, "first");
+							doh.assertTrue(elementsEqual(child, nodes.first.firstChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "first - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "first", "first");
+							doh.assertTrue(elementsEqual(child, nodes.first.firstChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "first - place html string with fragment reference",
+						runTest: function(t){
+							construct.place(HTMLString, fragment, "first");
+							doh.assertTrue(elementsEqual(child, fragment.firstChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "first - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.first, "first");
+							doh.assertEqual(child, nodes.first.firstChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "first - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "first", "first");
+							doh.assertEqual(child, nodes.first.firstChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "first - place node with fragment reference",
+						runTest: function(t){
+							construct.place(child, fragment, "first");
+							doh.assertEqual(child, fragment.firstChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "before - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.before, "before");
+							doh.assertTrue(elementsEqual(child, nodes.before.previousSibling));
+						}
+					},{
+						setUp: clearTarget,
+						name: "before - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "before", "before");
+							doh.assertTrue(elementsEqual(child, nodes.before.previousSibling));
+						}
+					},{
+						setUp: clearTarget,
+						name: "before - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.before, "before");
+							doh.assertTrue(child, nodes.before.previousSibling);
+						}
+					},{
+						setUp: clearTarget,
+						name: "before - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "before", "before");
+							doh.assertEqual(child, nodes.before.previousSibling);
+						}
+					},{
+						setUp: clearTarget,
+						name: "after - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.after, "after");
+							doh.assertTrue(elementsEqual(child, nodes.after.nextSibling));
+						}
+					},{
+						setUp: clearTarget,
+						name: "after - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "after", "after");
+							doh.assertTrue(elementsEqual(child, nodes.after.nextSibling));
+						}
+					},{
+						setUp: clearTarget,
+						name: "after - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.after, "after");
+							doh.assertEqual(child, nodes.after.nextSibling);
+						}
+					},{
+						setUp: clearTarget,
+						name: "after - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "after", "after");
+							doh.assertEqual(child, nodes.after.nextSibling);
+						}
+					},{
+						setUp: clearTarget,
+						name: "replace - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.replace, "replace");
+							doh.assertEqual(document.getElementById("replace"), undefined);
+							doh.assertTrue(elementsEqual(child, document.getElementById('test')));
+						}
+					},{
+						setUp: clearTarget,
+						name: "replace - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "replace", "replace");
+							doh.assertEqual(document.getElementById("replace"), undefined);
+							doh.assertTrue(elementsEqual(child, document.getElementById('test')));
+						}
+					},{
+						setUp: clearTarget,
+						name: "replace - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.replace, "replace");
+							doh.assertEqual(document.getElementById("replace"), undefined);
+							doh.assertEqual(child, document.getElementById('test'));
+						}
+					},{
+						setUp: clearTarget,
+						name: "replace - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "replace", "replace");
+							doh.assertEqual(document.getElementById("replace"), undefined);
+							doh.assertEqual(child, document.getElementById('test'));
+						}
+					},{
+						setUp: clearTarget,
+						name: "only - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.only, "only");
+							doh.assertEqual(nodes.only.children.length, 1);
+							doh.assertTrue(elementsEqual(child, nodes.only.firstChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "only - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "only", "only");
+							doh.assertEqual(nodes.only.children.length, 1);
+							doh.assertTrue(elementsEqual(child, nodes.only.firstChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "only - place html string with fragment reference",
+						runTest: function(t){
+							construct.place(HTMLString, fragment, "only");
+							doh.assertEqual(fragment.childNodes.length, 1);
+							doh.assertTrue(elementsEqual(child, fragment.firstChild));
+						}
+					},{
+						setUp: clearTarget,
+						name: "only - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.only, "only");
+							doh.assertEqual(child, nodes.only.firstChild);
+							doh.assertEqual(1, nodes.only.children.length);
+						}
+					},{
+						setUp: clearTarget,
+						name: "only - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "only", "only");
+							doh.assertEqual(child, nodes.only.firstChild);
+							doh.assertEqual(1, nodes.only.children.length);
+						}
+					},{
+						setUp: clearTarget,
+						name: "only - place node with fragment reference",
+						runTest: function(t){
+							construct.place(child, fragment, "only");
+							doh.assertEqual(fragment.childNodes.length, 1);
+							doh.assertEqual(child, fragment.firstChild);
+						}
+					},{
+						setUp: clearTarget,
+						name: "pos - place html string with node reference",
+						runTest: function(t){
+							construct.place(HTMLString, nodes.pos, TEST_POSITION);
+							doh.assertTrue(elementsEqual(child, nodes.pos.children[TEST_POSITION]));
+						}
+					},{
+						setUp: clearTarget,
+						name: "pos - place html string with id reference",
+						runTest: function(t){
+							construct.place(HTMLString, "pos", TEST_POSITION);
+							doh.assertTrue(elementsEqual(child, nodes.pos.children[TEST_POSITION]));
+						}
+					},{
+						setUp: clearTarget,
+						name: "pos - place html string with fragment reference",
+						runTest: function(t){
+							construct.place(HTMLString, fragment, TEST_POSITION);
+							doh.assertTrue(elementsEqual(child, fragment.childNodes[TEST_POSITION]));
+						}
+					},{
+						setUp: clearTarget,
+						name: "pos - place node with node reference",
+						runTest: function(t){
+							construct.place(child, nodes.pos, TEST_POSITION);
+							doh.assertEqual(child, nodes.pos.children[TEST_POSITION]);
+						}
+					},{
+						setUp: clearTarget,
+						name: "pos - place node with id reference",
+						runTest: function(t){
+							construct.place(child, "pos", TEST_POSITION);
+							doh.assertEqual(child, nodes.pos.children[TEST_POSITION]);
+						}
+					},{
+						setUp: clearTarget,
+						name: "pos - place node with fragment reference",
+						runTest: function(t){
+							construct.place(child, fragment, TEST_POSITION);
+							doh.assertEqual(child, fragment.childNodes[TEST_POSITION]);
+						}
+					}
+
+				]);
+
+				doh.run();
+			});
+		</script>
+	</head>
+	<body>
+		<div id="target"></div>
+	</body>
+</html>
diff --git a/tests/dom-construct.js b/tests/dom-construct.js
new file mode 100644
index 0000000..ff308d0
--- /dev/null
+++ b/tests/dom-construct.js
@@ -0,0 +1,23 @@
+define([
+	"dojo/dom-construct",
+	"doh",
+	"require"
+], function(construct, doh, require){
+
+	if(doh.isBrowser){
+		doh.register("tests.dom-construct-place", require.toUrl("./dom-construct-place.html"), 30000);
+	}
+
+	doh.register("tests.dom-construct", [
+		{
+			name: "Create element with textContent",
+			runTest: function(t){
+				var x = construct.create("div", {
+					textContent: "<b>this is bold</b>"
+				});
+				t.is("&lt;b&gt;this is bold&lt;/b&gt;", x.innerHTML, "textContent was not properly set");
+			}
+		}
+	]);
+
+});
diff --git a/tests/dom-prop.html b/tests/dom-prop.html
new file mode 100644
index 0000000..6ad4385
--- /dev/null
+++ b/tests/dom-prop.html
@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>testing dom-prop</title>
+		<script src="../dojo.js" data-dojo-config="isDebug:true"></script>
+		<script>
+			require(["dojo", "doh", "dojo/dom-prop", "dojo/dom", "dojo/domReady!"], function(dojo, doh, domProp, dom){
+				doh.register([
+					{
+						name: "set / get Attribute",
+						runTest: function(t){
+							var node = dom.byId("node"),
+								content = domProp.get(dom.byId("content1"), "textContent"),
+								content2 = domProp.get(dom.byId("content2"), "textContent"),
+								content3 = domProp.get(dom.byId("content3"), "textContent"),
+								content4 = domProp.get(dom.byId("content4"), "textContent");
+							node.innerHTML = "" //empty the node before testing
+							
+							doh.is(true, content != null); //test is getter works
+							doh.is("Etiam", content.substr(0, 5)); //test if getters return the expected value
+							
+							domProp.set(node, "textContent", content);
+							doh.is(content, node.innerHTML); //test is setter works (no text transformation exepcted because it's just a simple word)
+							
+							domProp.set(node, "textContent", "<b>this is bold</b>");
+							doh.is(-1, node.innerHTML.indexOf("<")); //test if setter escape properly the content
+							
+							domProp.set(node, "textContent", content2);
+
+							var test = node.innerHTML.replace(/\n/g, "");
+							doh.is(-1, test.indexOf("(comment)")); //test if html comments are ignored
+							doh.is(content4, content3);
+						}
+					}
+				]);
+
+				doh.run();
+			});
+		</script>
+	</head>
+	<body>
+	<div id="content1">Etiam</div>
+	<div id="content2">
+		<!-- <p>This should not show (comment).</p>-->
+	</div>
+	<div id="content3">
+	first line
+		second line
+			third line
+	fourth line
+	</div>
+	<div id="content4">
+	first line
+		<span>second line</span>
+		<span>	<span>third line</span></span>
+	fourth line
+	</div>
+	<pre id="node"></pre>
+	</body>
+</html>
diff --git a/tests/dom-prop.js b/tests/dom-prop.js
new file mode 100644
index 0000000..e2df79c
--- /dev/null
+++ b/tests/dom-prop.js
@@ -0,0 +1,3 @@
+define(["doh/main", "require"], function(doh, require){
+	doh.register("tests.dom-prop", require.toUrl("./dom-prop.html"), 30000);
+});
diff --git a/tests/dom-style.html b/tests/dom-style.html
index 86849e4..e36aa4c 100644
--- a/tests/dom-style.html
+++ b/tests/dom-style.html
@@ -30,6 +30,11 @@
 								doh.t(false);
 							}
 						}
+					},
+					function getWidth(){
+						// see http://bugs.dojotoolkit.org/ticket/17962
+						var rowWidth = domStyle.get(dom.byId("trow"), "width");
+						doh.t(rowWidth > 0, "width: " + rowWidth);
 					}
 				]);

@@ -39,5 +44,6 @@
 	</head>
 	<body>
 	<div id="node" style="padding: 1px 2px 3px 4px;"></div>
+	<table><tbody><tr id="trow"><td>Col A</td><td>Col B</td></tr></tbody></table>
 	</body>
 </html>
diff --git a/tests/query/query.html b/tests/query/query.html
index 592f1ad..f65a9b2 100644
--- a/tests/query/query.html
+++ b/tests/query/query.html
@@ -12,8 +12,8 @@
 			var selector = specified ? specified[0].split("=")[1] : "acme";

 			require(["doh", "dojo/_base/array", "dojo/dom", "dojo/request/iframe",
-				"dojo/query!"+selector, "dojo/NodeList", "dojo/sniff", "dojo/domReady!"],
-					function(doh, array, dom, iframe, dq, NodeList, has){
+				"dojo/query!"+selector, "dojo/NodeList", "dojo/sniff", "dojo/dom-construct", "dojo/domReady!"],
+					function(doh, array, dom, iframe, dq, NodeList, has, domConstruct){
 				query = dq; // make a global

 				function createDocument(xml){
@@ -236,6 +236,21 @@
 						var i = query("div");
 						// smoke test
 						i.sort(function(a,b){ return 1; })
+					},
+					function document_fragment() {
+						var detachedDom = domConstruct.toDom("<i><u><a></a><b id='b'></b></u></i>");
+						var documentFragment = domConstruct.toDom("<i></i>    <u><a></a><b id='b'></b></u>");
+
+						doh.is(1, query("#b", detachedDom).length);
+						doh.is(1, query("#b", detachedDom.firstChild).length);
+						doh.is(1, query("#b", documentFragment).length);
+						doh.is(1, query("#b", documentFragment.childNodes[2]).length);
+
+						var detachedDom2 = domConstruct.toDom("<i><u><a></a><b></b></u></i>");
+						var documentFragment2 = domConstruct.toDom("<i></i>    <u><a></a><b></b></u>");
+
+						doh.is(0, query("#b", detachedDom2).length);
+						doh.is(0, query("#b", documentFragment2).length);
 					}
 				]);

diff --git a/tests/query/queryQuirks.html b/tests/query/queryQuirks.html
index 8612e35..749249d 100644
--- a/tests/query/queryQuirks.html
+++ b/tests/query/queryQuirks.html
@@ -10,8 +10,8 @@
 			var specified = window.location.search.substr(1).match(/selector=(.*)/);
 			var selector = specified ? specified[0].split("=")[1] : "acme";

-			require(["dojo", "doh", "dojo/query!"+selector, "dojo/sniff", "dojo/io/iframe", "dojo/domReady!"],
-					function(dojo, doh, dq, has){
+			require(["dojo", "doh", "dojo/query!"+selector, "dojo/sniff", "dojo/dom-construct", "dojo/io/iframe", "dojo/domReady!"],
+					function(dojo, doh, dq, has, domConstruct){
 				query = dq; // make a global

 				function createDocument(xml){
@@ -219,6 +219,27 @@
 						var i = query("div");
 						// smoke test
 						i.sort(function(a,b){ return 1; })
+					},
+					function document_fragment() {
+						var detachedDom = domConstruct.toDom("<i><u><a></a><b id='b'></b></u></i>");
+						var documentFragment = domConstruct.toDom("<i></i>    <u><a></a><b id='b'></b></u>");
+
+						doh.is(1, query("#b", detachedDom).length);
+						doh.is(1, query("#b", detachedDom.firstChild).length);
+						doh.is(1, query("#b", documentFragment).length);
+
+						// In IE8 in quirks mode there is no text node on the document fragment
+						if(has('ie') === 8) {
+							doh.is(1, query("#b", documentFragment.childNodes[1]).length);
+						} else {
+							doh.is(1, query("#b", documentFragment.childNodes[2]).length);
+						}
+
+						var detachedDom2 = domConstruct.toDom("<i><u><a></a><b></b></u></i>");
+						var documentFragment2 = domConstruct.toDom("<i></i>    <u><a></a><b></b></u>");
+
+						doh.is(0, query("#b", detachedDom2).length);
+						doh.is(0, query("#b", documentFragment2).length);
 					}
 				]);

