diff --git a/doc/API.md b/doc/API.md
index 5e7f730b4a..9ceed246a6 100644
--- a/doc/API.md
+++ b/doc/API.md
@@ -328,7 +328,7 @@ The options parameter is flexible way to configure how `axe.run` operates. The d
 Additionally, there are a number or properties that allow configuration of different options:
 
 | Property        | Default | Description                |
-|-----------------|:-------:|:----------------------------:|
+|-----------------|:-------|:----------------------------|
 | `runOnly`       | n/a     | Limit which rules are executed, based on names or tags
 | `rules`         | n/a     | Allow customizing a rule's properties (including { enable: false })
 | `reporter`      | `v1`    | Which reporter to use (see [Configuration](#api-name-axeconfigure))
@@ -339,6 +339,7 @@ Additionally, there are a number or properties that allow configuration of diffe
 | `elementRef`    | `false` | Return element references in addition to the target
 | `restoreScroll` | `false` | Scrolls elements back to before axe started
 | `frameWaitTime` | `60000` | How long (in milliseconds) axe waits for a response from embedded frames before timing out
+| `preload`       | `false` | Any additional assets (eg: cssom) to preload before running rules. [See here for configuration details](#preload-configuration-details)
 
 ###### Options Parameter Examples
 
@@ -460,6 +461,28 @@ Additionally, there are a number or properties that allow configuration of diffe
   ```
   This example will process all of the "violations", "incomplete", and "inapplicable" result types. Since "passes" was not specified, it will only process the first pass for each rule, if one exists. As a result, the results object's `passes` array will have a length of either `0` or `1`. On a series of extremely large pages, this would improve performance considerably.
 
+###### <a id='preload-configuration-details'></a> Preload Configuration in Options Parameter
+
+The preload attribute in options parameter accepts a `boolean` or an `object` where an array of assets can be specified. 
+
+1. Specifying a `boolean`
+
+```js
+preload: true
+```
+
+2. Specifying an `object`
+```js
+preload: { assets: ['cssom'], timeout: 50000 }
+```
+The `assets` attribute expects an array of preload(able) constraints to be fetched. The current set of values supported for `assets` is listed in the following table:
+
+| Asset Type | Description |
+|:-----------|:------------|
+| `cssom`    | This asset type preloads all CSS Stylesheets rulesets specified in the page. The stylessheets can be an external cross-domain resource, a relative stylesheet or an inline style with in the head tag of the document. If the stylesheet is an external cross-domain a network request is made. An object representing the CSS Rules from each stylesheet is made available to the checks evaluate function as `preloadedAssets` at run-time |
+
+The `timeout` attribute in the object configuration is `optional` and has a fallback default value (10000ms). The `timeout` is essential for any network dependent assets that are preloaded, where-in if a given request takes longer than the specified/ default value, the operation is aborted.
+
 ##### Callback Parameter
 
 The callback parameter is a function that will be called when the asynchronous `axe.run` function completes. The callback function is passed two parameters. The first parameter will be an error thrown inside of aXe if axe.run could not complete. If axe completed correctly the first parameter will be null, and the second parameter will be the results object.
diff --git a/lib/checks/aria/aria-hidden-body.json b/lib/checks/aria/aria-hidden-body.json
index c4d2d85cca..bad069615e 100644
--- a/lib/checks/aria/aria-hidden-body.json
+++ b/lib/checks/aria/aria-hidden-body.json
@@ -8,4 +8,4 @@
       "fail": "aria-hidden=true should not be present on the document body"
     }
   }
-}
+}
\ No newline at end of file
diff --git a/lib/commons/dom/get-root-node.js b/lib/commons/dom/get-root-node.js
index 59fbd86556..3aa7209ef1 100644
--- a/lib/commons/dom/get-root-node.js
+++ b/lib/commons/dom/get-root-node.js
@@ -7,12 +7,6 @@
  * @instance
  * @param {Element} node
  * @returns {DocumentFragment|Document}
+ * @deprecated use axe.utils.getRootNode
  */
-dom.getRootNode = function(node) {
-	var doc = (node.getRootNode && node.getRootNode()) || document; // this is for backwards compatibility
-	if (doc === node) {
-		// disconnected node
-		doc = document;
-	}
-	return doc;
-};
+dom.getRootNode = axe.utils.getRootNode;
diff --git a/lib/core/constants.js b/lib/core/constants.js
index ed13e6e334..af9897ba86 100644
--- a/lib/core/constants.js
+++ b/lib/core/constants.js
@@ -31,7 +31,9 @@
 		results: [],
 		resultGroups: [],
 		resultGroupMap: {},
-		impact: Object.freeze(['minor', 'moderate', 'serious', 'critical'])
+		impact: Object.freeze(['minor', 'moderate', 'serious', 'critical']),
+		preloadAssets: Object.freeze(['cssom']), // overtime this array will grow with other preload asset types, this constant is to verify if a requested preload type by the user via the configuration is supported by axe.
+		preloadAssetsTimeout: 10000
 	};
 
 	definitions.forEach(function(definition) {
diff --git a/lib/core/utils/get-root-node.js b/lib/core/utils/get-root-node.js
new file mode 100644
index 0000000000..43c13a046c
--- /dev/null
+++ b/lib/core/utils/get-root-node.js
@@ -0,0 +1,18 @@
+/* global axe */
+
+/**
+ * Return the document or document fragment (shadow DOM)
+ * @method getRootNode
+ * @memberof axe.utils
+ * @instance
+ * @param {Element} node
+ * @returns {DocumentFragment|Document}
+ */
+axe.utils.getRootNode = function getRootNode(node) {
+	var doc = (node.getRootNode && node.getRootNode()) || document; // this is for backwards compatibility
+	if (doc === node) {
+		// disconnected node
+		doc = document;
+	}
+	return doc;
+};
diff --git a/lib/core/utils/preload-cssom.js b/lib/core/utils/preload-cssom.js
new file mode 100644
index 0000000000..b3388dba38
--- /dev/null
+++ b/lib/core/utils/preload-cssom.js
@@ -0,0 +1,205 @@
+/**
+ * Returns a then(able) queue of CSSStyleSheet(s)
+ * @param {Object} ownerDocument document object to be inspected for stylesheets
+ * @param {number} timeout on network request for stylesheet that need to be externally fetched
+ * @param {Function} convertTextToStylesheetFn a utility function to generate a style sheet from text
+ * @return {Object} queue
+ * @private
+ */
+function loadCssom({ root, shadowId }, timeout, convertTextToStylesheetFn) {
+	/**
+	 * Make an axios get request to fetch a given resource and resolve
+	 * @method getExternalStylesheet
+	 * @private
+	 * @param {Object} param an object with properties to configure the external XHR
+	 * @property {Object} param.resolve resolve callback on queue
+	 * @property {Object} param.reject reject callback on queue
+	 * @property {String} param.url string representing the url of the resource to load
+	 * @property {Number} param.timeout timeout to about network call
+	 */
+	function getExternalStylesheet({ resolve, reject, url }) {
+		axe.imports
+			.axios({
+				method: 'get',
+				url,
+				timeout
+			})
+			.then(({ data }) => {
+				const sheet = convertTextToStylesheetFn({
+					data,
+					isExternal: true,
+					shadowId
+				});
+				resolve(sheet);
+			})
+			.catch(reject);
+	}
+
+	const q = axe.utils.queue();
+
+	// iterate to decipher multi-level nested sheets if any (this is essential to retrieve styles from shadowDOM)
+	Array.from(root.styleSheets).forEach(sheet => {
+		// ignore disabled sheets
+		if (sheet.disabled) {
+			return;
+		}
+		// attempt to retrieve cssRules, or for external sheets make a XMLHttpRequest
+		try {
+			// accessing .cssRules throws for external (cross-domain) sheets, which is handled in the catch
+			const cssRules = sheet.cssRules;
+			// read all css rules in the sheet
+			const rules = Array.from(cssRules);
+
+			// filter rules that are included by way of @import or nested link
+			const importRules = rules.filter(r => r.href);
+
+			// if no import or nested link rules, with in these cssRules
+			// return current sheet
+			if (!importRules.length) {
+				q.defer(resolve =>
+					resolve({
+						sheet,
+						isExternal: false,
+						shadowId
+					})
+				);
+				return;
+			}
+
+			// if any import rules exists, fetch via `href` which eventually constructs a sheet with results from resource
+			importRules.forEach(rule => {
+				q.defer((resolve, reject) => {
+					getExternalStylesheet({ resolve, reject, url: rule.href });
+				});
+			});
+
+			// in the same sheet -  get inline rules in <style> tag or in a CSSStyleSheet excluding @import or nested link
+			const inlineRules = rules.filter(rule => !rule.href);
+
+			// concat all cssText into a string for inline rules
+			const inlineRulesCssText = inlineRules
+				.reduce((out, rule) => {
+					out.push(rule.cssText);
+					return out;
+				}, [])
+				.join();
+			// create and return a sheet with inline rules
+			q.defer(resolve =>
+				resolve(
+					convertTextToStylesheetFn({
+						data: inlineRulesCssText,
+						shadowId,
+						isExternal: false
+					})
+				)
+			);
+		} catch (e) {
+			// if no href, do not attempt to make an XHR, but this is preventive check
+			// NOTE: as further enhancements to resolve nested @imports are done, a decision to throw an Error if necessary here will be made.
+			if (!sheet.href) {
+				return;
+			}
+			// external sheet -> make an xhr and q the response
+			q.defer((resolve, reject) => {
+				getExternalStylesheet({ resolve, reject, url: sheet.href });
+			});
+		}
+	}, []);
+	// return
+	return q;
+}
+
+/**
+ * Returns an array of objects with root(document)
+ * @param {Object} treeRoot the DOM tree to be inspected
+ * @return {Array<Object>} array of objects, which each object containing a root (document) and an optional shadowId
+ * @private
+ */
+function getAllRootsInTree(tree) {
+	let ids = [];
+	const documents = axe.utils
+		.querySelectorAllFilter(tree, '*', node => {
+			if (ids.includes(node.shadowId)) {
+				return false;
+			}
+			ids.push(node.shadowId);
+			return true;
+		})
+		.map(node => {
+			return {
+				shadowId: node.shadowId,
+				root: axe.utils.getRootNode(node.actualNode)
+			};
+		});
+	return documents;
+}
+
+/**
+ * @method preloadCssom
+ * @memberof axe.utils
+ * @instance
+ * @param {Object} object argument which is a composite object, with attributes timeout, treeRoot(optional), resolve & reject
+ * @property {Number} timeout timeout for any network calls made
+ * @property {Object} treeRoot the DOM tree to be inspected
+ * @return {Object} a queue with results of cssom assets
+ */
+axe.utils.preloadCssom = function preloadCssom({
+	timeout,
+	treeRoot = axe._tree[0]
+}) {
+	const roots = axe.utils.uniqueArray(getAllRootsInTree(treeRoot), []);
+	const q = axe.utils.queue();
+
+	if (!roots.length) {
+		return q;
+	}
+
+	const dynamicDoc = document.implementation.createHTMLDocument();
+
+	/**
+	 * Convert text content to CSSStyleSheet
+	 * @method convertTextToStylesheet
+	 * @private
+	 * @param {Object} param an object with properties to construct stylesheet
+	 * @property {String} param.data text content of the stylesheet
+	 * @property {Boolean} param.isExternal flag to notify if the resource was fetched from the network
+	 * @property {Object} param.doc implementation document to create style elements
+	 * @property {String} param.shadowId (Optional) shadowId if shadowDOM
+	 */
+	function convertTextToStylesheet({ data, isExternal, shadowId }) {
+		const style = dynamicDoc.createElement('style');
+		style.type = 'text/css';
+		style.appendChild(dynamicDoc.createTextNode(data));
+		dynamicDoc.head.appendChild(style);
+		return {
+			sheet: style.sheet,
+			isExternal,
+			shadowId
+		};
+	}
+
+	q.defer((resolve, reject) => {
+		// as there can be multiple documents (root document, shadow document fragments, and frame documents)
+		// reduce these into a queue
+		roots
+			.reduce((out, root) => {
+				out.defer((resolve, reject) => {
+					loadCssom(root, timeout, convertTextToStylesheet)
+						.then(resolve)
+						.catch(reject);
+				});
+				return out;
+			}, axe.utils.queue())
+			// await loading all such documents assets, and concat results into one object
+			.then(assets => {
+				resolve(
+					assets.reduce((out, cssomSheets) => {
+						return out.concat(cssomSheets);
+					}, [])
+				);
+			})
+			.catch(reject);
+	});
+
+	return q;
+};
diff --git a/lib/core/utils/preload.js b/lib/core/utils/preload.js
new file mode 100644
index 0000000000..f0d62ed548
--- /dev/null
+++ b/lib/core/utils/preload.js
@@ -0,0 +1,104 @@
+/**
+ * Validated the preload object
+ * @param {Object | boolean} preload configuration object or boolean passed via the options parameter to axe.run
+ * @return {boolean}
+ * @private
+ */
+function isValidPreloadObject(preload) {
+	return typeof preload === 'object' && Array.isArray(preload.assets);
+}
+
+/**
+ * Returns a boolean which decides if preload is configured
+ * @param {Object} options run configuration options (or defaults) passed via axe.run
+ * @return {boolean}
+ */
+axe.utils.shouldPreload = function shouldPreload(options) {
+	if (!options || !options.preload) {
+		return false;
+	}
+	if (typeof options.preload === 'boolean') {
+		return options.preload;
+	}
+	return isValidPreloadObject(options.preload);
+};
+
+/**
+ * Constructs a configuration object representing the preload requested assets & timeout
+ * @param {Object} options run configuration options (or defaults) passed via axe.run
+ * @return {Object}
+ */
+axe.utils.getPreloadConfig = function getPreloadConfig(options) {
+	// default fallback configuration
+	const config = {
+		assets: axe.constants.preloadAssets,
+		timeout: axe.constants.preloadAssetsTimeout
+	};
+
+	// if type is boolean
+	if (typeof options.preload === 'boolean') {
+		return config;
+	}
+
+	// check if requested assets to preload are valid items
+	const areRequestedAssetsValid = options.preload.assets.every(a =>
+		axe.constants.preloadAssets.includes(a.toLowerCase())
+	);
+
+	if (!areRequestedAssetsValid) {
+		throw new Error(
+			`Requested assets, not supported. ` +
+				`Supported assets are: ${axe.constants.preloadAssets.join(', ')}.`
+		);
+	}
+
+	// unique assets to load, in case user had requested same asset type many times.
+	config.assets = axe.utils.uniqueArray(
+		options.preload.assets.map(a => a.toLowerCase()),
+		[]
+	);
+
+	if (
+		options.preload.timeout &&
+		typeof options.preload.timeout === 'number' &&
+		!Number.isNaN(options.preload.timeout)
+	) {
+		config.timeout = options.preload.timeout;
+	}
+	return config;
+};
+
+/**
+ * Returns a then(able) queue with results of all requested preload(able) assets. Eg: ['cssom'].
+ * If preload is set to false, returns an empty queue.
+ * @param {Object} options run configuration options (or defaults) passed via axe.run
+ * @return {Object} queue
+ */
+axe.utils.preload = function preload(options) {
+	const preloadFunctionsMap = {
+		cssom: axe.utils.preloadCssom
+	};
+
+	const q = axe.utils.queue();
+
+	const shouldPreload = axe.utils.shouldPreload(options);
+	if (!shouldPreload) {
+		return q;
+	}
+
+	const preloadConfig = axe.utils.getPreloadConfig(options);
+
+	preloadConfig.assets.forEach(asset => {
+		q.defer((resolve, reject) => {
+			preloadFunctionsMap[asset](preloadConfig)
+				.then(results => {
+					resolve({
+						[asset]: results[0]
+					});
+				})
+				.catch(reject);
+		});
+	});
+
+	return q;
+};
diff --git a/lib/rules/aria-hidden-body.json b/lib/rules/aria-hidden-body.json
index 023f5c9c4c..ae1cefe268 100644
--- a/lib/rules/aria-hidden-body.json
+++ b/lib/rules/aria-hidden-body.json
@@ -16,4 +16,4 @@
     "aria-hidden-body"
   ],
   "none": []
-}
+}
\ No newline at end of file
diff --git a/test/commons/dom/get-root-node.js b/test/core/utils/get-root-node.js
similarity index 77%
rename from test/commons/dom/get-root-node.js
rename to test/core/utils/get-root-node.js
index 6ba6cad93e..23f2f1e2c1 100644
--- a/test/commons/dom/get-root-node.js
+++ b/test/core/utils/get-root-node.js
@@ -6,7 +6,7 @@ function makeShadowTreeGRN(node) {
 	root.appendChild(div);
 }
 
-describe('dom.getRootNode', function() {
+describe('axe.utils.getRootNode', function() {
 	'use strict';
 
 	var fixture = document.getElementById('fixture');
@@ -19,11 +19,11 @@ describe('dom.getRootNode', function() {
 	it('should return the document when the node is just a normal node', function() {
 		fixture.innerHTML = '<div id="target"></div>';
 		var node = document.getElementById('target');
-		assert.isTrue(axe.commons.dom.getRootNode(node) === document);
+		assert.isTrue(axe.utils.getRootNode(node) === document);
 	});
 	it('should return the document when the node is disconnected', function() {
 		var node = document.createElement('div');
-		assert.isTrue(axe.commons.dom.getRootNode(node) === document);
+		assert.isTrue(axe.utils.getRootNode(node) === document);
 	});
 	it('should return the shadow root when it is inside the shadow DOM', function() {
 		var shadEl;
@@ -34,9 +34,9 @@ describe('dom.getRootNode', function() {
 			fixture.innerHTML = '<div></div>';
 			makeShadowTreeGRN(fixture.firstChild);
 			shadEl = fixture.firstChild.shadowRoot.querySelector('div');
-			assert.isTrue(axe.commons.dom.getRootNode(shadEl) !== document);
+			assert.isTrue(axe.utils.getRootNode(shadEl) !== document);
 			assert.isTrue(
-				axe.commons.dom.getRootNode(shadEl) === fixture.firstChild.shadowRoot
+				axe.utils.getRootNode(shadEl) === fixture.firstChild.shadowRoot
 			);
 		}
 	});
diff --git a/test/core/utils/preload-cssom.js b/test/core/utils/preload-cssom.js
new file mode 100644
index 0000000000..e9f3fbfb03
--- /dev/null
+++ b/test/core/utils/preload-cssom.js
@@ -0,0 +1,90 @@
+describe('axe.utils.preloadCssom unit tests', function() {
+	'use strict';
+
+	var args;
+
+	function addStyleToHead() {
+		var css = 'html {font-size: inherit;}';
+		var head = document.head || document.getElementsByTagName('head')[0];
+		var style = document.createElement('style');
+		style.id = 'preloadCssomTestHeadSheet';
+		style.type = 'text/css';
+		style.appendChild(document.createTextNode(css));
+		head.appendChild(style);
+	}
+
+	function removeStyleFromHead() {
+		var s = document.getElementById('preloadCssomTestHeadSheet');
+		if (s) {
+			s.parentNode.removeChild(s);
+		}
+	}
+
+	beforeEach(function() {
+		addStyleToHead();
+		args = {
+			asset: 'cssom',
+			timeout: 10000,
+			treeRoot: (axe._tree = axe.utils.getFlattenedTree(document))
+		};
+	});
+
+	afterEach(function() {
+		removeStyleFromHead();
+	});
+
+	it('should be a function', function() {
+		assert.isFunction(axe.utils.preloadCssom);
+	});
+
+	it('should return a queue', function() {
+		var actual = axe.utils.preloadCssom(args);
+		assert.isObject(actual);
+		assert.containsAllKeys(actual, ['then', 'defer', 'catch']);
+	});
+
+	it('should ensure result of cssom is an array of sheets', function(done) {
+		var actual = axe.utils.preloadCssom(args);
+		actual
+			.then(function(results) {
+				assert.lengthOf(results[0], 2); // returned from queue, hence the index look up
+				done();
+			})
+			.catch(function(error) {
+				done(error);
+			});
+	});
+
+	it('should fail if number of sheets returned does not match stylesheets defined in document', function(done) {
+		var actual = axe.utils.preloadCssom(args);
+		actual
+			.then(function(results) {
+				assert.isFalse(results[0].length <= 1); // returned from queue, hence the index look up
+				done();
+			})
+			.catch(function(error) {
+				done(error);
+			});
+	});
+
+	it('should ensure all returned stylesheet is defined and has property cssRules', function(done) {
+		var actual = axe.utils.preloadCssom(args);
+		actual
+			.then(function(results) {
+				var sheets = results[0];
+				sheets.forEach(function(s) {
+					assert.isDefined(s.sheet);
+					assert.property(s.sheet, 'cssRules');
+				});
+				done();
+			})
+			.catch(function(error) {
+				done(error);
+			});
+	});
+
+	/**
+	 * NOTE: document.styleSheets does not recognise dynamically injected stylesheets after load via beforeEach/ before, so tests for disabled and external stylesheets are done in integration
+	 * Refer Directory: ./test/full/preload-cssom/**.*
+	 */
+});
diff --git a/test/core/utils/preload.js b/test/core/utils/preload.js
new file mode 100644
index 0000000000..78d91f141f
--- /dev/null
+++ b/test/core/utils/preload.js
@@ -0,0 +1,139 @@
+describe('axe.utils.preload', function() {
+	'use strict';
+
+	it('should return a queue', function() {
+		var options = {
+			preload: true
+		};
+		var actual = axe.utils.preload(options);
+		assert.isObject(actual);
+		assert.containsAllKeys(actual, ['then', 'defer', 'catch']);
+	});
+
+	it('should ensure queue is defer(able)', function(done) {
+		var options = {
+			preload: false
+		};
+		var actual = axe.utils.preload(options);
+		actual
+			.defer(function(res, rej) {
+				assert.isFunction(rej);
+				res(true);
+				done();
+			})
+			.catch(function(error) {
+				done(error);
+			});
+	});
+
+	it('should ensure queue is then(able)', function(done) {
+		var options = {
+			preload: false
+		};
+		var actual = axe.utils.preload(options);
+		actual
+			.then(function(results) {
+				assert.isDefined(results);
+				done();
+			})
+			.catch(function(error) {
+				done(error);
+			});
+	});
+
+	it('should return an object with property cssom and verify result is same output from preloadCssom', function(done) {
+		var options = {
+			preload: {
+				assets: ['cssom']
+			}
+		};
+		var actual = axe.utils.preload(options);
+		actual
+			.then(function(results) {
+				assert.isDefined(results);
+				assert.isArray(results);
+				assert.property(results[0], 'cssom');
+				// also verify that result from css matches that of preloadCssom
+				axe.utils.preloadCssom(options).then(function(resultFromPreloadCssom) {
+					assert.deepEqual(results[0].cssom, resultFromPreloadCssom[0]);
+					done();
+				});
+			})
+			.catch(function(error) {
+				done(error);
+			});
+	});
+
+	describe('axe.utils.shouldPreload', function() {
+		it('should return true if preload configuration is valid', function() {
+			var options = {
+				preload: true
+			};
+			var actual = axe.utils.shouldPreload(options);
+			assert.isTrue(actual);
+		});
+
+		it('should return false if preload configuration is invalid', function() {
+			var options = {
+				preload: {
+					errorProperty: ['cssom']
+				}
+			};
+			var actual = axe.utils.shouldPreload(options);
+			assert.isFalse(actual);
+		});
+	});
+
+	describe('axe.utils.getPreloadConfig', function() {
+		it('should throw error if preload configuration is invalid', function() {
+			var actual = function() {
+				axe.utils.getPreloadConfig({});
+			};
+			var expected = Error;
+			assert.throws(actual, expected);
+		});
+
+		it('should return default assets if preload options is set to true', function() {
+			var options = {
+				preload: true
+			};
+			var actual = axe.utils.getPreloadConfig(options).assets;
+			var expected = ['cssom'];
+			assert.deepEqual(actual, expected);
+		});
+
+		it('should return default timeout value if not configured', function() {
+			var options = {
+				preload: true
+			};
+			var actual = axe.utils.getPreloadConfig(options).timeout;
+			var expected = 10000;
+			assert.equal(actual, expected);
+		});
+
+		it('should throw error if requested asset type is not supported', function() {
+			var options = {
+				preload: {
+					assets: ['some-unsupported-asset']
+				}
+			};
+			var actual = function() {
+				axe.utils.getPreloadConfig(options);
+			};
+			var expected = Error;
+			assert.throws(actual, expected);
+		});
+
+		it('should remove any duplicate assets passed via preload configuration', function() {
+			var options = {
+				preload: {
+					assets: ['cssom', 'cssom']
+				}
+			};
+			var actual = axe.utils.getPreloadConfig(options);
+			assert.property(actual, 'assets');
+			assert.containsAllKeys(actual, ['assets', 'timeout']);
+			assert.lengthOf(actual.assets, 1);
+		});
+	});
+});
diff --git a/test/integration/full/preload-cssom/frames/level1.html b/test/integration/full/preload-cssom/frames/level1.html
new file mode 100644
index 0000000000..007f4e3edb
--- /dev/null
+++ b/test/integration/full/preload-cssom/frames/level1.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+<head>
+	<meta charset="utf8">
+	<!-- external cross origin stylesheet -->
+	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/pure/1.0.0/pure-min.css">
+	<!-- external cross origin stylesheet media print -->
+	<link rel="stylesheet" href="https://unpkg.com/gutenberg-css@0.4" media="print">
+	<!-- relative same origin stylesheet -->
+	<link disabled rel="stylesheet" type="text/css" href="/node_modules/mocha/mocha.css" />
+	<!-- inline stylesheet -->
+	<style>
+		.inline-frame-css-test {
+			font-size: inherit;
+		}
+	</style>
+	<script src="/axe.js"></script>
+</head>
+</html>
diff --git a/test/integration/full/preload-cssom/preload-cssom-shadow-blue.css b/test/integration/full/preload-cssom/preload-cssom-shadow-blue.css
new file mode 100644
index 0000000000..97c8b38329
--- /dev/null
+++ b/test/integration/full/preload-cssom/preload-cssom-shadow-blue.css
@@ -0,0 +1,3 @@
+.blue{
+	background-color: blue;
+}
\ No newline at end of file
diff --git a/test/integration/full/preload-cssom/preload-cssom-shadow-red.css b/test/integration/full/preload-cssom/preload-cssom-shadow-red.css
new file mode 100644
index 0000000000..513b61263b
--- /dev/null
+++ b/test/integration/full/preload-cssom/preload-cssom-shadow-red.css
@@ -0,0 +1,3 @@
+.red{
+	background-color: red;
+}
\ No newline at end of file
diff --git a/test/integration/full/preload-cssom/preload-cssom.css b/test/integration/full/preload-cssom/preload-cssom.css
new file mode 100644
index 0000000000..53398d8833
--- /dev/null
+++ b/test/integration/full/preload-cssom/preload-cssom.css
@@ -0,0 +1,5 @@
+@import 'preload-cssom-shadow-blue.css';
+
+html {
+	font-weight: inherit;
+}
\ No newline at end of file
diff --git a/test/integration/full/preload-cssom/preload-cssom.html b/test/integration/full/preload-cssom/preload-cssom.html
new file mode 100644
index 0000000000..74ff0bdbf0
--- /dev/null
+++ b/test/integration/full/preload-cssom/preload-cssom.html
@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en" id="pass1">
+<head>
+	<meta charset="utf8">
+	<!-- external cross origin stylesheet -->
+	<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css">
+	<!-- disabled external cross origin stylesheet -->
+	<link disabled rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.css">
+	<!-- external cross origin stylesheet media print -->
+	<link rel="stylesheet" href="https://unpkg.com/gutenberg-css@0.4" media="print">
+	<!-- disabled external cross origin stylesheet media print -->
+	<link disabled rel="stylesheet" href="https://unpkg.com/gutenberg-css@0.4" media="print">
+	<!-- relative same origin stylesheet -->
+	<link rel="stylesheet" type="text/css" href="/node_modules/mocha/mocha.css" >
+	<!-- disable relative stylesheet -->
+	<link disabled rel="stylesheet" type="text/css" href="preload-cssom.css">
+	<!-- inline stylesheet -->
+	<style>
+		@import "preload-cssom-shadow-blue.css";
+		.inline-css-test {
+			font-size: inherit;
+		}
+	</style>
+	<script src="/node_modules/mocha/mocha.js"></script>
+	<script src="/node_modules/chai/chai.js"></script>
+	<script src="/axe.js"></script>
+	<script>
+		mocha.setup({
+			timeout: 10000,
+			ui: 'bdd'
+		});
+		var assert = chai.assert;
+	</script>
+</head>
+<body>
+	<iframe id="frame1" src="frames/level1.html"></iframe>
+	<div id="mocha"></div>
+	<div id="shadow-fixture"></div>
+	<div class="blue">blue on parent page</div>
+	<script src="/test/testutils.js"></script>
+	<script src="preload-cssom.js"></script>
+	<script src="/test/integration/adapter.js"></script>
+</body>
+</html>
diff --git a/test/integration/full/preload-cssom/preload-cssom.js b/test/integration/full/preload-cssom/preload-cssom.js
new file mode 100644
index 0000000000..af380a6a0f
--- /dev/null
+++ b/test/integration/full/preload-cssom/preload-cssom.js
@@ -0,0 +1,279 @@
+/* global axe, Promise */
+describe('preload cssom integration test pass', function() {
+	'use strict';
+
+	var origAxios;
+	var shadowSupported = axe.testUtils.shadowSupport.v1;
+
+	before(function(done) {
+		function start() {
+			// cache original axios object
+			if (axe.imports.axios) {
+				origAxios = axe.imports.axios;
+			}
+			// run axe
+			axe.run(
+				{
+					preload: true
+				},
+				function(err) {
+					assert.isNull(err);
+					done();
+				}
+			);
+		}
+		if (document.readyState !== 'complete') {
+			window.addEventListener('load', start);
+		} else {
+			start();
+		}
+	});
+
+	function createStub(shouldReject) {
+		/**
+		 * This is a simple override to stub `axe.imports.axios`, until the test-suite is enhanced.
+		 * Did not use any library such as sinon for this, as sinon.stub have difficulties working under selenium webdriver
+		 * Also a generic XHR override was overlooked under webdriver
+		 */
+		axe.imports.axios = function stubbedAxios() {
+			return new Promise(function(resolve, reject) {
+				if (shouldReject) {
+					reject(new Error('Fake Error'));
+				}
+				resolve({
+					data: 'body{overflow:auto;}'
+				});
+			});
+		};
+	}
+
+	function restoreStub() {
+		if (origAxios) {
+			axe.imports.axios = origAxios;
+		}
+	}
+
+	function assertStylesheet(sheet, selectorText, cssText) {
+		assert.isDefined(sheet);
+		assert.property(sheet, 'cssRules');
+		assert.equal(sheet.cssRules[0].selectorText, selectorText);
+		assert.equal(sheet.cssRules[0].cssText.replace(/\s/g, ''), cssText);
+	}
+
+	function getPreload(root) {
+		var config = {
+			asset: 'cssom',
+			timeout: 10000,
+			treeRoot: axe.utils.getFlattenedTree(root ? root : document)
+		};
+		return axe.utils.preloadCssom(config);
+	}
+
+	function commonTestsForRootAndFrame(root) {
+		shouldIt(
+			'should return external stylesheet from cross-domain and verify response',
+			function(done) {
+				getPreload(root)
+					.then(function(results) {
+						var sheets = results[0];
+						var externalSheet = sheets.filter(function(s) {
+							return s.isExternal;
+						})[0].sheet;
+						assertStylesheet(externalSheet, 'body', 'body{overflow:auto;}');
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		shouldIt('should reject if external stylesheet fail to load', function(
+			done
+		) {
+			restoreStub();
+			createStub(true);
+			var doneCalled = false;
+			getPreload(root)
+				.then(done)
+				.catch(function(error) {
+					assert.equal(error.message, 'Fake Error');
+					if (!doneCalled) {
+						done();
+					}
+					doneCalled = true;
+				});
+		});
+	}
+
+	beforeEach(function() {
+		createStub();
+	});
+
+	afterEach(function() {
+		restoreStub();
+	});
+
+	var shouldIt = window.PHANTOMJS ? it.skip : it;
+
+	describe('tests for current top level document', function() {
+		shouldIt(
+			'should return inline stylesheets defined using <style> tag',
+			function(done) {
+				getPreload()
+					.then(function(results) {
+						var sheets = results[0];
+						var nonExternalsheets = sheets.filter(function(s) {
+							return !s.isExternal;
+						});
+						assert.lengthOf(nonExternalsheets, 2);
+						var inlineStylesheet = nonExternalsheets.filter(function(s) {
+							return s.sheet.rules.length === 1;
+						})[0].sheet;
+						assertStylesheet(
+							inlineStylesheet,
+							'.inline-css-test',
+							'.inline-css-test{font-size:inherit;}'
+						);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		shouldIt('should return relative stylesheets with in same-origin', function(
+			done
+		) {
+			getPreload()
+				.then(function(results) {
+					var sheets = results[0];
+					var relativeSheets = sheets.filter(function(s) {
+						return !s.isExternal;
+					});
+					assert.lengthOf(relativeSheets, 2);
+					var relativeSheet = relativeSheets.filter(function(s) {
+						return s.sheet.rules.length > 1;
+					})[0].sheet;
+					assertStylesheet(relativeSheet, 'body', 'body{margin:0px;}');
+					done();
+				})
+				.catch(done);
+		});
+
+		shouldIt(
+			'should return all external stylesheets with or with(out) media attribute that are not disabled',
+			function(done) {
+				getPreload()
+					.then(function(results) {
+						var sheets = results[0];
+						var externalSheets = sheets.filter(function(s) {
+							return s.isExternal;
+						});
+						assert.lengthOf(externalSheets, 3);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		shouldIt(
+			'should ignore disabled stylesheets with or with(out) media attribute',
+			function(done) {
+				getPreload()
+					.then(function(results) {
+						var sheets = results[0];
+						assert.lengthOf(sheets, 5);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		if (!window.PHANTOMJS) {
+			(shadowSupported ? it : xit)(
+				'should return styles from shadow dom',
+				function(done) {
+					var fixture = document.getElementById('shadow-fixture');
+					var shadow = fixture.attachShadow({ mode: 'open' });
+					shadow.innerHTML =
+						'<style>@import "https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.css"; @import "preload-cssom-shadow-blue.css"; .green { background-color: green; }</style>' +
+						'<div class="initialism">Some text</div>' +
+						'<div class="green">green</div>' +
+						'<div class="red">red</div>' +
+						'' +
+						'<h1>Heading</h1>';
+					getPreload(fixture)
+						.then(function(results) {
+							var sheets = results[0];
+							// verify count
+							assert.lengthOf(sheets, 8);
+							// verify that the last non external sheet with shadowId has green selector
+							var nonExternalsheetsWithShadowId = sheets
+								.filter(function(s) {
+									return !s.isExternal;
+								})
+								.filter(function(s) {
+									return s.shadowId;
+								});
+							assertStylesheet(
+								nonExternalsheetsWithShadowId[
+									nonExternalsheetsWithShadowId.length - 1
+								].sheet,
+								'.green',
+								'.green{background-color:green;}'
+							);
+							done();
+						})
+						.catch(done);
+				}
+			);
+		}
+
+		commonTestsForRootAndFrame();
+	});
+
+	describe('tests for nested iframe', function() {
+		var frame;
+
+		before(function() {
+			frame = document.getElementById('frame1').contentDocument;
+		});
+
+		shouldIt(
+			'should return correct number of stylesheets, ignores disabled',
+			function(done) {
+				getPreload(frame)
+					.then(function(results) {
+						var sheets = results[0];
+						assert.lengthOf(sheets, 3);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		shouldIt(
+			'should return inline stylesheets defined using <style> tag',
+			function(done) {
+				getPreload(frame)
+					.then(function(results) {
+						var sheets = results[0];
+						var nonExternalsheets = sheets.filter(function(s) {
+							return !s.isExternal;
+						});
+						assert.lengthOf(nonExternalsheets, 1);
+						var inlineStylesheet = nonExternalsheets.filter(function(s) {
+							return s.sheet.rules.length === 1;
+						})[0].sheet;
+						assertStylesheet(
+							inlineStylesheet,
+							'.inline-frame-css-test',
+							'.inline-frame-css-test{font-size:inherit;}'
+						);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		commonTestsForRootAndFrame(frame);
+	});
+});