diff --git a/lib/checks/label/explicit-evaluate.js b/lib/checks/label/explicit-evaluate.js
index d3410c2124..fadb1af36c 100644
--- a/lib/checks/label/explicit-evaluate.js
+++ b/lib/checks/label/explicit-evaluate.js
@@ -2,22 +2,26 @@ import { getRootNode, isVisible } from '../../commons/dom';
 import { accessibleText } from '../../commons/text';
 import { escapeSelector } from '../../core/utils';
 
-function explicitEvaluate(node) {
-	if (node.getAttribute('id')) {
-		const root = getRootNode(node);
-		const id = escapeSelector(node.getAttribute('id'));
-		const label = root.querySelector(`label[for="${id}"]`);
+function explicitEvaluate(node, options, virtualNode) {
+	try {
+		if (virtualNode.attr('id')) {
+			const root = getRootNode(virtualNode.actualNode);
+			const id = escapeSelector(virtualNode.attr('id'));
+			const label = root.querySelector(`label[for="${id}"]`);
 
-		if (label) {
-			// defer to hidden-explicit-label check for better messaging
-			if (!isVisible(label)) {
-				return true;
-			} else {
-				return !!accessibleText(label);
+			if (label) {
+				// defer to hidden-explicit-label check for better messaging
+				if (!isVisible(label)) {
+					return true;
+				} else {
+					return !!accessibleText(label);
+				}
 			}
 		}
+		return false;
+	} catch (e) {
+		return undefined;
 	}
-	return false;
 }
 
 export default explicitEvaluate;
diff --git a/lib/checks/label/explicit.json b/lib/checks/label/explicit.json
index defced373b..511b68c4d0 100644
--- a/lib/checks/label/explicit.json
+++ b/lib/checks/label/explicit.json
@@ -5,7 +5,8 @@
 		"impact": "critical",
 		"messages": {
 			"pass": "Form element has an explicit <label>",
-			"fail": "Form element does not have an explicit <label>"
+			"fail": "Form element does not have an explicit <label>",
+			"incomplete": "Unable to determine if form element has an explicit <label>"
 		}
 	}
 }
diff --git a/lib/checks/label/hidden-explicit-label-evaluate.js b/lib/checks/label/hidden-explicit-label-evaluate.js
index dd910b2fef..dfa2999b15 100644
--- a/lib/checks/label/hidden-explicit-label-evaluate.js
+++ b/lib/checks/label/hidden-explicit-label-evaluate.js
@@ -3,18 +3,22 @@ import { accessibleTextVirtual } from '../../commons/text';
 import { escapeSelector } from '../../core/utils';
 
 function hiddenExplicitLabelEvaluate(node, options, virtualNode) {
-	if (node.getAttribute('id')) {
-		const root = getRootNode(node);
-		const id = escapeSelector(node.getAttribute('id'));
-		const label = root.querySelector(`label[for="${id}"]`);
+	try {
+		if (virtualNode.hasAttr('id')) {
+			const root = getRootNode(node);
+			const id = escapeSelector(node.getAttribute('id'));
+			const label = root.querySelector(`label[for="${id}"]`);
 
-		if (label && !isVisible(label, true)) {
-			const name = accessibleTextVirtual(virtualNode).trim();
-			const isNameEmpty = name === '';
-			return isNameEmpty;
+			if (label && !isVisible(label, true)) {
+				const name = accessibleTextVirtual(virtualNode).trim();
+				const isNameEmpty = name === '';
+				return isNameEmpty;
+			}
 		}
+		return false;
+	} catch (e) {
+		return undefined;
 	}
-	return false;
 }
 
 export default hiddenExplicitLabelEvaluate;
diff --git a/lib/checks/label/hidden-explicit-label.json b/lib/checks/label/hidden-explicit-label.json
index 5dc6e1c6e6..f6e8633da5 100644
--- a/lib/checks/label/hidden-explicit-label.json
+++ b/lib/checks/label/hidden-explicit-label.json
@@ -5,7 +5,8 @@
 		"impact": "critical",
 		"messages": {
 			"pass": "Form element has a visible explicit <label>",
-			"fail": "Form element has explicit <label> that is hidden"
+			"fail": "Form element has explicit <label> that is hidden",
+			"incomplete": "Unable to determine if form element has explicit <label> that is hidden"
 		}
 	}
 }
diff --git a/lib/checks/label/implicit-evaluate.js b/lib/checks/label/implicit-evaluate.js
index 39c3bc9d7d..be47c98b17 100644
--- a/lib/checks/label/implicit-evaluate.js
+++ b/lib/checks/label/implicit-evaluate.js
@@ -1,12 +1,16 @@
-import { findUpVirtual } from '../../commons/dom';
-import { accessibleText } from '../../commons/text';
+import { closest } from '../../core/utils';
+import { accessibleTextVirtual } from '../../commons/text';
 
 function implicitEvaluate(node, options, virtualNode) {
-	const label = findUpVirtual(virtualNode, 'label');
-	if (label) {
-		return !!accessibleText(label, { inControlContext: true });
+	try {
+		const label = closest(virtualNode, 'label');
+		if (label) {
+			return !!accessibleTextVirtual(label, { inControlContext: true });
+		}
+		return false;
+	} catch (e) {
+		return undefined;
 	}
-	return false;
 }
 
 export default implicitEvaluate;
diff --git a/lib/checks/label/implicit.json b/lib/checks/label/implicit.json
index 61417927fd..8b891cf040 100644
--- a/lib/checks/label/implicit.json
+++ b/lib/checks/label/implicit.json
@@ -5,7 +5,8 @@
 		"impact": "critical",
 		"messages": {
 			"pass": "Form element has an implicit (wrapped) <label>",
-			"fail": "Form element does not have an implicit (wrapped) <label>"
+			"fail": "Form element does not have an implicit (wrapped) <label>",
+			"incomplete": "Unable to determine if form element has an implicit (wrapped} <label>"
 		}
 	}
 }
diff --git a/lib/commons/aria/label-virtual.js b/lib/commons/aria/label-virtual.js
index 803b214e1e..063220ebc8 100644
--- a/lib/commons/aria/label-virtual.js
+++ b/lib/commons/aria/label-virtual.js
@@ -8,15 +8,15 @@ import sanitize from '../text/sanitize';
  * @method labelVirtual
  * @memberof axe.commons.aria
  * @instance
- * @param  {Object} actualNode The virtualNode to test
+ * @param  {VirtualNode} virtualNode The virtualNode to test
  * @return {Mixed}  String of visible text, or `null` if no label is found
  */
-function labelVirtual({ actualNode }) {
+function labelVirtual(virtualNode) {
 	let ref, candidate;
 
-	if (actualNode.getAttribute('aria-labelledby')) {
+	if (virtualNode.attr('aria-labelledby')) {
 		// aria-labelledby
-		ref = idrefs(actualNode, 'aria-labelledby');
+		ref = idrefs(virtualNode.actualNode, 'aria-labelledby');
 		candidate = ref
 			.map(function(thing) {
 				// TODO: es-module-utils.getNodeFromTree
@@ -32,7 +32,7 @@ function labelVirtual({ actualNode }) {
 	}
 
 	// aria-label
-	candidate = actualNode.getAttribute('aria-label');
+	candidate = virtualNode.attr('aria-label');
 	if (candidate) {
 		candidate = sanitize(candidate).trim();
 		if (candidate) {
diff --git a/lib/commons/dom/is-visible.js b/lib/commons/dom/is-visible.js
index 1a71bd3526..b355beab08 100644
--- a/lib/commons/dom/is-visible.js
+++ b/lib/commons/dom/is-visible.js
@@ -104,7 +104,12 @@ function isAreaVisible(el, screenReader, recursed) {
  * @return {Boolean} The element's visibilty status
  */
 function isVisible(el, screenReader, recursed) {
-	'use strict';
+	if (!el) {
+		throw new TypeError(
+			'Cannot determine if element is visible for non-DOM nodes'
+		);
+	}
+
 	const vNode = getNodeFromTree(el);
 	const cacheName = '_isVisible' + (screenReader ? 'ScreenReader' : '');
 
diff --git a/lib/commons/standards/implicit-html-roles.js b/lib/commons/standards/implicit-html-roles.js
index 63072923b9..d759484e96 100644
--- a/lib/commons/standards/implicit-html-roles.js
+++ b/lib/commons/standards/implicit-html-roles.js
@@ -99,11 +99,14 @@ const implicitHtmlRoles = {
 	},
 	input: vNode => {
 		// Source: https://www.w3.org/TR/html52/sec-forms.html#suggestions-source-element
-		const listElement = idrefs(vNode.actualNode, 'list').filter(
-			node => !!node
-		)[0];
-		const suggestionsSourceElement =
-			listElement && listElement.nodeName.toLowerCase() === 'datalist';
+		let suggestionsSourceElement;
+		if (vNode.hasAttr('list')) {
+			const listElement = idrefs(vNode.actualNode, 'list').filter(
+				node => !!node
+			)[0];
+			suggestionsSourceElement =
+				listElement && listElement.nodeName.toLowerCase() === 'datalist';
+		}
 
 		switch ((vNode.attr('type') || '').toLowerCase()) {
 			case 'button':
diff --git a/lib/commons/text/form-control-value.js b/lib/commons/text/form-control-value.js
index a931933e70..7b7405667b 100644
--- a/lib/commons/text/form-control-value.js
+++ b/lib/commons/text/form-control-value.js
@@ -10,6 +10,8 @@ import isAriaCombobox from '../forms/is-aria-combobox';
 import isAriaRange from '../forms/is-aria-range';
 import getOwnedVirtual from '../aria/get-owned-virtual';
 import isHiddenWithCSS from '../dom/is-hidden-with-css';
+import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-node';
+import { getNodeFromTree, querySelectorAll } from '../../core/utils';
 
 const controlValueRoles = [
 	'textbox',
@@ -80,9 +82,11 @@ function formControlValue(virtualNode, context = {}) {
  * @return {string} The calculated value
  */
 function nativeTextboxValue(node) {
-	node = node.actualNode || node;
-	if (isNativeTextbox(node)) {
-		return node.value || '';
+	const vNode =
+		node instanceof AbstractVirtualNode ? node : getNodeFromTree(node);
+
+	if (isNativeTextbox(vNode)) {
+		return vNode.props.value || '';
 	}
 	return '';
 }
@@ -94,16 +98,22 @@ function nativeTextboxValue(node) {
  * @return {string} The calculated value
  */
 function nativeSelectValue(node) {
-	node = node.actualNode || node;
-	if (!isNativeSelect(node)) {
+	const vNode =
+		node instanceof AbstractVirtualNode ? node : getNodeFromTree(node);
+
+	if (!isNativeSelect(vNode)) {
 		return '';
 	}
-	return (
-		Array.from(node.options)
-			.filter(option => option.selected)
-			.map(option => option.text)
-			.join(' ') || ''
-	);
+
+	const options = querySelectorAll(vNode, 'option');
+	const selectedOptions = options.filter(option => option.hasAttr('selected'));
+
+	// browser automatically selects the first option
+	if (!selectedOptions.length) {
+		selectedOptions.push(options[0]);
+	}
+
+	return selectedOptions.map(option => visibleVirtual(option)).join(' ') || '';
 }
 
 /**
@@ -112,13 +122,16 @@ function nativeSelectValue(node) {
  * @param {VirtualNode} element The VirtualNode instance whose value we want
  * @return {string} The calculated value
  */
-function ariaTextboxValue(virtualNode) {
-	const { actualNode } = virtualNode;
-	if (!isAriaTextbox(actualNode)) {
+function ariaTextboxValue(node) {
+	const vNode =
+		node instanceof AbstractVirtualNode ? node : getNodeFromTree(node);
+
+	let { actualNode } = vNode;
+	if (!isAriaTextbox(vNode)) {
 		return '';
 	}
-	if (!isHiddenWithCSS(actualNode)) {
-		return visibleVirtual(virtualNode, true);
+	if (!actualNode || (actualNode && !isHiddenWithCSS(actualNode))) {
+		return visibleVirtual(vNode, true);
 	} else {
 		return actualNode.textContent;
 	}
@@ -134,16 +147,17 @@ function ariaTextboxValue(virtualNode) {
  * @property {Bool} debug Enable logging for formControlValue
  * @return {string} The calculated value
  */
-function ariaListboxValue(virtualNode, context) {
-	const { actualNode } = virtualNode;
-	if (!isAriaListbox(actualNode)) {
+function ariaListboxValue(node, context) {
+	const vNode =
+		node instanceof AbstractVirtualNode ? node : getNodeFromTree(node);
+
+	if (!isAriaListbox(vNode)) {
 		return '';
 	}
 
-	const selected = getOwnedVirtual(virtualNode).filter(
+	const selected = getOwnedVirtual(vNode).filter(
 		owned =>
-			getRole(owned) === 'option' &&
-			owned.actualNode.getAttribute('aria-selected') === 'true'
+			getRole(owned) === 'option' && owned.attr('aria-selected') === 'true'
 	);
 
 	if (selected.length === 0) {
@@ -165,17 +179,16 @@ function ariaListboxValue(virtualNode, context) {
  * @property {Bool} debug Enable logging for formControlValue
  * @return {string} The calculated value
  */
-function ariaComboboxValue(virtualNode, context) {
-	const { actualNode } = virtualNode;
+function ariaComboboxValue(node, context) {
+	const vNode =
+		node instanceof AbstractVirtualNode ? node : getNodeFromTree(node);
 	let listbox;
 
 	// For combobox, find the first owned listbox:
-	if (!isAriaCombobox(actualNode)) {
+	if (!isAriaCombobox(vNode)) {
 		return '';
 	}
-	listbox = getOwnedVirtual(virtualNode).filter(
-		elm => getRole(elm) === 'listbox'
-	)[0];
+	listbox = getOwnedVirtual(vNode).filter(elm => getRole(elm) === 'listbox')[0];
 
 	return listbox ? ariaListboxValue(listbox, context) : '';
 }
@@ -187,13 +200,15 @@ function ariaComboboxValue(virtualNode, context) {
  * @return {string} The calculated value
  */
 function ariaRangeValue(node) {
-	node = node.actualNode || node;
-	if (!isAriaRange(node) || !node.hasAttribute('aria-valuenow')) {
+	const vNode =
+		node instanceof AbstractVirtualNode ? node : getNodeFromTree(node);
+
+	if (!isAriaRange(vNode) || !vNode.hasAttr('aria-valuenow')) {
 		return '';
 	}
 	// Validate the number, if not, return 0.
 	// Chrome 70 typecasts this, Firefox 62 does not
-	const valueNow = +node.getAttribute('aria-valuenow');
+	const valueNow = +vNode.attr('aria-valuenow');
 	return !isNaN(valueNow) ? String(valueNow) : '0';
 }
 
diff --git a/lib/commons/text/label-virtual.js b/lib/commons/text/label-virtual.js
index 7883fe013f..5ca153eeb4 100644
--- a/lib/commons/text/label-virtual.js
+++ b/lib/commons/text/label-virtual.js
@@ -1,7 +1,8 @@
 import ariaLabelVirtual from '../aria/label-virtual';
 import visible from './visible';
+import visibleVirtual from './visible-virtual';
 import getRootNode from '../dom/get-root-node';
-import findUpVirtual from '../dom/find-up-virtual';
+import { closest, escapeSelector } from '../../core/utils';
 
 /**
  * Gets the visible text of a label for a given input
@@ -12,19 +13,24 @@ import findUpVirtual from '../dom/find-up-virtual';
  * @param  {VirtualNode} node The virtual node mapping to the input to test
  * @return {Mixed} String of visible text, or `null` if no label is found
  */
-function labelVirtual(node) {
+function labelVirtual(virtualNode) {
 	var ref, candidate, doc;
 
-	candidate = ariaLabelVirtual(node);
+	candidate = ariaLabelVirtual(virtualNode);
 	if (candidate) {
 		return candidate;
 	}
 
 	// explicit label
-	if (node.actualNode.id) {
-		// TODO: es-module-utils.escapeSelector
-		const id = axe.utils.escapeSelector(node.actualNode.getAttribute('id'));
-		doc = getRootNode(node.actualNode);
+	if (virtualNode.attr('id')) {
+		if (!virtualNode.actualNode) {
+			throw new TypeError(
+				'Cannot resolve explicit label reference for non-DOM nodes'
+			);
+		}
+
+		const id = escapeSelector(virtualNode.attr('id'));
+		doc = getRootNode(virtualNode.actualNode);
 		ref = doc.querySelector('label[for="' + id + '"]');
 		candidate = ref && visible(ref, true);
 		if (candidate) {
@@ -32,8 +38,8 @@ function labelVirtual(node) {
 		}
 	}
 
-	ref = findUpVirtual(node, 'label');
-	candidate = ref && visible(ref, true);
+	ref = closest(virtualNode, 'label');
+	candidate = ref && visibleVirtual(ref, true);
 	if (candidate) {
 		return candidate;
 	}
diff --git a/lib/commons/text/visible-virtual.js b/lib/commons/text/visible-virtual.js
index 0929a2d887..7554da8709 100644
--- a/lib/commons/text/visible-virtual.js
+++ b/lib/commons/text/visible-virtual.js
@@ -1,5 +1,7 @@
 import sanitize from './sanitize';
 import isVisible from '../dom/is-visible';
+import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-node';
+import { getNodeFromTree } from '../../core/utils';
 
 /**
  * Returns the visible text of the virtual node
@@ -16,12 +18,21 @@ import isVisible from '../dom/is-visible';
  * @return {String}
  */
 function visibleVirtual(element, screenReader, noRecursing) {
-	const result = element.children
+	const vNode =
+		element instanceof AbstractVirtualNode ? element : getNodeFromTree(element);
+
+	// if the element does not have an actual node treat it as if
+	// it is visible
+	const visible =
+		!element.actualNode ||
+		(element.actualNode && isVisible(element.actualNode, screenReader));
+
+	const result = vNode.children
 		.map(child => {
-			if (child.actualNode.nodeType === 3) {
+			const { nodeType, nodeValue } = child.props;
+			if (nodeType === 3) {
 				// filter on text nodes
-				const nodeValue = child.actualNode.nodeValue;
-				if (nodeValue && isVisible(element.actualNode, screenReader)) {
+				if (nodeValue && visible) {
 					return nodeValue;
 				}
 			} else if (!noRecursing) {
diff --git a/lib/core/base/virtual-node/abstract-virtual-node.js b/lib/core/base/virtual-node/abstract-virtual-node.js
index 63697a25a4..9de917311f 100644
--- a/lib/core/base/virtual-node/abstract-virtual-node.js
+++ b/lib/core/base/virtual-node/abstract-virtual-node.js
@@ -2,7 +2,7 @@ const whitespaceRegex = /[\t\r\n\f]/g;
 
 class AbstractVirtualNode {
 	constructor() {
-		this.parent = null;
+		this.parent = undefined;
 	}
 
 	get props() {
diff --git a/lib/core/base/virtual-node/virtual-node.js b/lib/core/base/virtual-node/virtual-node.js
index 90473d273a..dcfdb44ac8 100644
--- a/lib/core/base/virtual-node/virtual-node.js
+++ b/lib/core/base/virtual-node/virtual-node.js
@@ -49,7 +49,14 @@ class VirtualNode extends AbstractVirtualNode {
 	// abstract Node properties so we can run axe in DOM-less environments.
 	// add to the prototype so memory is shared across all virtual nodes
 	get props() {
-		const { nodeType, nodeName, id, multiple, nodeValue } = this.actualNode;
+		const {
+			nodeType,
+			nodeName,
+			id,
+			multiple,
+			nodeValue,
+			value
+		} = this.actualNode;
 
 		return {
 			nodeType,
@@ -57,7 +64,8 @@ class VirtualNode extends AbstractVirtualNode {
 			id,
 			type: this._type,
 			multiple,
-			nodeValue
+			nodeValue,
+			value
 		};
 	}
 
diff --git a/lib/core/utils/closest.js b/lib/core/utils/closest.js
index 8b18b1b1bb..dfabe778c0 100644
--- a/lib/core/utils/closest.js
+++ b/lib/core/utils/closest.js
@@ -15,6 +15,12 @@ function closest(vNode, selector) {
 			return vNode;
 		}
 
+		// the top node of the tree will have parent === null, so a
+		// undefined parent means we are in a disconnected tree
+		if (typeof vNode.parent === 'undefined') {
+			throw new TypeError('Cannot resolve parent for non-DOM nodes');
+		}
+
 		vNode = vNode.parent;
 	}
 
diff --git a/lib/core/utils/get-flattened-tree.js b/lib/core/utils/get-flattened-tree.js
index c98c0e8609..9f481e0a37 100644
--- a/lib/core/utils/get-flattened-tree.js
+++ b/lib/core/utils/get-flattened-tree.js
@@ -141,7 +141,11 @@ function flattenTree(node, shadowId, parent) {
  */
 function getFlattenedTree(node = document.documentElement, shadowId) {
 	cache.set('nodeMap', new WeakMap());
-	return flattenTree(node, shadowId);
+
+	// specifically pass `null` to the parent to designate the top
+	// node of the tree. if parent === undefined then we know
+	// we are in a disconnected tree
+	return flattenTree(node, shadowId, null);
 }
 
 export default getFlattenedTree;
diff --git a/lib/rules/label-matches.js b/lib/rules/label-matches.js
index f948db6ff9..d4e65860fe 100644
--- a/lib/rules/label-matches.js
+++ b/lib/rules/label-matches.js
@@ -1,12 +1,12 @@
-function labelMatches(node) {
+function labelMatches(node, virtualNode) {
 	if (
-		node.nodeName.toLowerCase() !== 'input' ||
-		node.hasAttribute('type') === false
+		virtualNode.props.nodeName !== 'input' ||
+		virtualNode.hasAttr('type') === false
 	) {
 		return true;
 	}
 
-	var type = node.getAttribute('type').toLowerCase();
+	var type = virtualNode.attr('type').toLowerCase();
 	return (
 		['hidden', 'image', 'button', 'submit', 'reset'].includes(type) === false
 	);
diff --git a/test/checks/aria/no-implicit-explicit-label.js b/test/checks/aria/no-implicit-explicit-label.js
index 4873fc4a5b..cb6b22b055 100644
--- a/test/checks/aria/no-implicit-explicit-label.js
+++ b/test/checks/aria/no-implicit-explicit-label.js
@@ -44,7 +44,7 @@ describe('no-implicit-explicit-label', function() {
 	});
 
 	describe('SerialVirtualNode', function() {
-		it('should return false', function() {
+		it('should return false if there is no parent', function() {
 			var serialNode = new axe.SerialVirtualNode({
 				nodeName: 'div',
 				attributes: {
@@ -52,9 +52,23 @@ describe('no-implicit-explicit-label', function() {
 					'aria-label': 'woohoo'
 				}
 			});
+			serialNode.parent = null;
 
 			var actual = check.evaluate.call(checkContext, null, {}, serialNode);
 			assert.isFalse(actual);
 		});
+
+		it('should return undefined if incomplete tree', function() {
+			var serialNode = new axe.SerialVirtualNode({
+				nodeName: 'div',
+				attributes: {
+					role: 'combobox',
+					'aria-label': 'woohoo'
+				}
+			});
+
+			var actual = check.evaluate.call(checkContext, null, {}, serialNode);
+			assert.isUndefined(actual);
+		});
 	});
 });
diff --git a/test/checks/label/explicit.js b/test/checks/label/explicit.js
index bcef42a19b..d47eab5d31 100644
--- a/test/checks/label/explicit.js
+++ b/test/checks/label/explicit.js
@@ -3,6 +3,7 @@ describe('explicit-label', function() {
 
 	var fixture = document.getElementById('fixture');
 	var fixtureSetup = axe.testUtils.fixtureSetup;
+	var queryFixture = axe.testUtils.queryFixture;
 	var shadowSupport = axe.testUtils.shadowSupport;
 
 	afterEach(function() {
@@ -10,33 +11,37 @@ describe('explicit-label', function() {
 	});
 
 	it('should return false if an empty label is present', function() {
-		fixtureSetup('<label for="target"></label><input type="text" id="target">');
-		var node = fixture.querySelector('#target');
-		assert.isFalse(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+		var vNode = queryFixture(
+			'<label for="target"></label><input type="text" id="target">'
+		);
+		assert.isFalse(
+			axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+		);
 	});
 
 	it('should return true if a non-empty label is present', function() {
-		fixtureSetup(
+		var vNode = queryFixture(
 			'<label for="target">Text</label><input type="text" id="target">'
 		);
-		var node = fixture.querySelector('#target');
-		assert.isTrue(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+		assert.isTrue(
+			axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+		);
 	});
 
 	it('should return true if an invisible non-empty label is present, to defer to hidden-explicit-label', function() {
-		fixtureSetup(
+		var vNode = queryFixture(
 			'<label for="target" style="display: none;">Text</label><input type="text" id="target">'
 		);
-		var node = fixture.querySelector('#target');
-		assert.isTrue(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+		assert.isTrue(
+			axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+		);
 	});
 
 	it('should return false if a label is not present', function() {
-		var node = document.createElement('input');
-		node.type = 'text';
-		fixtureSetup(node);
-
-		assert.isFalse(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+		var vNode = queryFixture('<input type="text" id="target" />');
+		assert.isFalse(
+			axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+		);
 	});
 
 	(shadowSupport.v1 ? it : xit)(
@@ -48,8 +53,10 @@ describe('explicit-label', function() {
 				'<label for="target">American band</label><input id="target">';
 			fixtureSetup(root);
 
-			var node = shadow.querySelector('#target');
-			assert.isTrue(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+			var vNode = axe.utils.getNodeFromTree(shadow.querySelector('#target'));
+			assert.isTrue(
+				axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+			);
 		}
 	);
 
@@ -63,8 +70,10 @@ describe('explicit-label', function() {
 				'<label for="target"><slot></slot></label><input id="target">';
 			fixtureSetup(root);
 
-			var node = shadow.querySelector('#target');
-			assert.isTrue(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+			var vNode = axe.utils.getNodeFromTree(shadow.querySelector('#target'));
+			assert.isTrue(
+				axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+			);
 		}
 	);
 
@@ -77,8 +86,10 @@ describe('explicit-label', function() {
 			shadow.innerHTML = '<slot></slot><input id="target">';
 			fixtureSetup(root);
 
-			var node = shadow.querySelector('#target');
-			assert.isFalse(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+			var vNode = axe.utils.getNodeFromTree(shadow.querySelector('#target'));
+			assert.isFalse(
+				axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+			);
 		}
 	);
 
@@ -92,8 +103,25 @@ describe('explicit-label', function() {
 				'<label for="target">American band</label><slot></slot>';
 			fixtureSetup(root);
 
-			var node = root.querySelector('#target');
-			assert.isFalse(axe.testUtils.getCheckEvaluate('explicit-label')(node));
+			var vNode = axe.utils.getNodeFromTree(root.querySelector('#target'));
+			assert.isFalse(
+				axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, vNode)
+			);
 		}
 	);
+
+	describe('SerialVirtualNode', function() {
+		it('should return undefined', function() {
+			var virtualNode = new axe.SerialVirtualNode({
+				nodeName: 'input',
+				attributes: {
+					type: 'text'
+				}
+			});
+
+			assert.isFalse(
+				axe.testUtils.getCheckEvaluate('explicit-label')(null, {}, virtualNode)
+			);
+		});
+	});
 });
diff --git a/test/checks/label/hidden-explicit-label.js b/test/checks/label/hidden-explicit-label.js
index 2961aa5b91..d7c61daea8 100644
--- a/test/checks/label/hidden-explicit-label.js
+++ b/test/checks/label/hidden-explicit-label.js
@@ -87,4 +87,31 @@ describe('hidden-explicit-label', function() {
 			});
 		});
 	});
+
+	describe('SerialVirtualNode', function() {
+		it('should return false if no id', function() {
+			var vNode = new axe.SerialVirtualNode({
+				nodeName: 'input',
+				attributes: {
+					type: 'text'
+				}
+			});
+			assert.isFalse(
+				axe.testUtils.getCheckEvaluate('hidden-explicit-label')(null, {}, vNode)
+			);
+		});
+
+		it('should return undefined if it has id', function() {
+			var vNode = new axe.SerialVirtualNode({
+				nodeName: 'input',
+				attributes: {
+					type: 'text',
+					id: 'foobar'
+				}
+			});
+			assert.isUndefined(
+				axe.testUtils.getCheckEvaluate('hidden-explicit-label')(null, {}, vNode)
+			);
+		});
+	});
 });
diff --git a/test/checks/label/implicit.js b/test/checks/label/implicit.js
index 5514600da6..731b1bc2b7 100644
--- a/test/checks/label/implicit.js
+++ b/test/checks/label/implicit.js
@@ -14,7 +14,7 @@ describe('implicit-label', function() {
 		var node = fixture.querySelector('#target');
 		var virtualNode = axe.utils.getNodeFromTree(node);
 		assert.isFalse(
-			axe.testUtils.getCheckEvaluate('implicit-label')(node, {}, virtualNode)
+			axe.testUtils.getCheckEvaluate('implicit-label')(null, {}, virtualNode)
 		);
 	});
 
@@ -25,7 +25,7 @@ describe('implicit-label', function() {
 		var node = fixture.querySelector('#target');
 		var virtualNode = axe.utils.getNodeFromTree(node);
 		assert.isFalse(
-			axe.testUtils.getCheckEvaluate('implicit-label')(node, {}, virtualNode)
+			axe.testUtils.getCheckEvaluate('implicit-label')(null, {}, virtualNode)
 		);
 	});
 
@@ -34,7 +34,7 @@ describe('implicit-label', function() {
 		var node = fixture.querySelector('#target');
 		var virtualNode = axe.utils.getNodeFromTree(node);
 		assert.isTrue(
-			axe.testUtils.getCheckEvaluate('implicit-label')(node, {}, virtualNode)
+			axe.testUtils.getCheckEvaluate('implicit-label')(null, {}, virtualNode)
 		);
 	});
 
@@ -45,7 +45,36 @@ describe('implicit-label', function() {
 
 		var virtualNode = axe.utils.getNodeFromTree(node);
 		assert.isFalse(
-			axe.testUtils.getCheckEvaluate('implicit-label')(node, {}, virtualNode)
+			axe.testUtils.getCheckEvaluate('implicit-label')(null, {}, virtualNode)
 		);
 	});
+
+	describe('SerialVirtualNode', function() {
+		it('should return false if no implicit label', function() {
+			var virtualNode = new axe.SerialVirtualNode({
+				nodeName: 'input',
+				attributes: {
+					type: 'text'
+				}
+			});
+			virtualNode.parent = null;
+
+			assert.isFalse(
+				axe.testUtils.getCheckEvaluate('implicit-label')(null, {}, virtualNode)
+			);
+		});
+
+		it('should return undefined if tree is not complete', function() {
+			var virtualNode = new axe.SerialVirtualNode({
+				nodeName: 'input',
+				attributes: {
+					type: 'text'
+				}
+			});
+
+			assert.isUndefined(
+				axe.testUtils.getCheckEvaluate('implicit-label')(null, {}, virtualNode)
+			);
+		});
+	});
 });
diff --git a/test/core/utils/closest.js b/test/core/utils/closest.js
index 83c4fe5b99..3edbb86284 100644
--- a/test/core/utils/closest.js
+++ b/test/core/utils/closest.js
@@ -42,6 +42,28 @@ describe('utils.closest', function() {
 		assert.isNull(closestNode);
 	});
 
+	it('should error if tree is not complete', function() {
+		var virtualNode = queryFixture('<div id="target">foo</div>');
+		virtualNode.parent = undefined;
+
+		function fn() {
+			closest(virtualNode, 'h1');
+		}
+
+		assert.throws(fn);
+	});
+
+	it('should not error if tree is complete', function() {
+		var virtualNode = queryFixture('<div id="target">foo</div>');
+		virtualNode.parent = null;
+
+		function fn() {
+			closest(virtualNode, 'h1');
+		}
+
+		assert.doesNotThrow(fn);
+	});
+
 	(shadowSupported ? it : xit)('should support shadow dom', function() {
 		fixture.innerHTML = '<div id="parent"></div>';
 
diff --git a/test/core/utils/flattened-tree.js b/test/core/utils/flattened-tree.js
index 1c9dd8dda3..cf13d9422a 100644
--- a/test/core/utils/flattened-tree.js
+++ b/test/core/utils/flattened-tree.js
@@ -81,6 +81,11 @@ describe('axe.utils.getFlattenedTree', function() {
 		assert(tree[0].actualNode === document.documentElement);
 	});
 
+	it('should set `null` on the parent for the root node', function() {
+		var tree = axe.utils.getFlattenedTree();
+		assert(tree[0].parent === null);
+	});
+
 	if (shadowSupport.v0) {
 		describe('shadow DOM v0', function() {
 			afterEach(function() {
diff --git a/test/integration/virtual-rules/aria-input-field-name.js b/test/integration/virtual-rules/aria-input-field-name.js
index e5fd5f544f..f5b41010d4 100644
--- a/test/integration/virtual-rules/aria-input-field-name.js
+++ b/test/integration/virtual-rules/aria-input-field-name.js
@@ -1,12 +1,15 @@
 describe('aria-input-field-name', function() {
 	it('should pass for aria-label', function() {
-		var results = axe.runVirtualRule('aria-input-field-name', {
+		var node = new axe.SerialVirtualNode({
 			nodeName: 'div',
 			attributes: {
 				role: 'combobox',
 				'aria-label': 'foobar'
 			}
 		});
+		node.parent = null;
+
+		var results = axe.runVirtualRule('aria-input-field-name', node);
 
 		assert.lengthOf(results.passes, 1);
 		assert.lengthOf(results.violations, 0);
@@ -14,13 +17,16 @@ describe('aria-input-field-name', function() {
 	});
 
 	it('should incomplete for aria-labelledby', function() {
-		var results = axe.runVirtualRule('aria-input-field-name', {
+		var node = new axe.SerialVirtualNode({
 			nodeName: 'div',
 			attributes: {
 				role: 'listbox',
 				'aria-labelledby': 'foobar'
 			}
 		});
+		node.parent = null;
+
+		var results = axe.runVirtualRule('aria-input-field-name', node);
 
 		assert.lengthOf(results.passes, 0);
 		assert.lengthOf(results.violations, 0);
@@ -38,6 +44,7 @@ describe('aria-input-field-name', function() {
 		// children are required since titleText comes after subtree text
 		// in accessible name calculation
 		node.children = [];
+		node.parent = null;
 
 		var results = axe.runVirtualRule('aria-input-field-name', node);
 
diff --git a/test/integration/virtual-rules/aria-toggle-field-name.js b/test/integration/virtual-rules/aria-toggle-field-name.js
index cd890a4fc7..153970cc72 100644
--- a/test/integration/virtual-rules/aria-toggle-field-name.js
+++ b/test/integration/virtual-rules/aria-toggle-field-name.js
@@ -1,12 +1,15 @@
 describe('aria-toggle-field-name', function() {
 	it('should pass for aria-label', function() {
-		var results = axe.runVirtualRule('aria-toggle-field-name', {
+		var node = new axe.SerialVirtualNode({
 			nodeName: 'div',
 			attributes: {
 				role: 'menuitemcheckbox',
 				'aria-label': 'foobar'
 			}
 		});
+		node.parent = null;
+
+		var results = axe.runVirtualRule('aria-toggle-field-name', node);
 
 		assert.lengthOf(results.passes, 1);
 		assert.lengthOf(results.violations, 0);
@@ -38,6 +41,7 @@ describe('aria-toggle-field-name', function() {
 		// children are required since titleText comes after subtree text
 		// in accessible name calculation
 		node.children = [];
+		node.parent = null;
 
 		var results = axe.runVirtualRule('aria-toggle-field-name', node);
 
@@ -59,6 +63,7 @@ describe('aria-toggle-field-name', function() {
 			nodeValue: 'foobar'
 		});
 		node.children = [child];
+		node.parent = null;
 
 		var results = axe.runVirtualRule('aria-toggle-field-name', node);
 
diff --git a/test/integration/virtual-rules/index.html b/test/integration/virtual-rules/index.html
index b59f993a17..ac4bb7216d 100644
--- a/test/integration/virtual-rules/index.html
+++ b/test/integration/virtual-rules/index.html
@@ -26,6 +26,7 @@
 		<script src="frame-title.js"></script>
 		<script src="input-image-alt.js"></script>
 		<script src="object-alt.js"></script>
+		<script src="label.js"></script>
 		<script src="button-name.js"></script>
 		<script src="input-button-name.js"></script>
 		<script src="aria-toggle-field-name.js"></script>
diff --git a/test/integration/virtual-rules/label.js b/test/integration/virtual-rules/label.js
new file mode 100644
index 0000000000..20d9a0ce03
--- /dev/null
+++ b/test/integration/virtual-rules/label.js
@@ -0,0 +1,165 @@
+describe('label', function() {
+	it('should not apply if input type is hidden', function() {
+		var results = axe.runVirtualRule('label', {
+			nodeName: 'input',
+			attributes: {
+				type: 'hidden'
+			}
+		});
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 0);
+		assert.lengthOf(results.inapplicable, 1);
+	});
+
+	it('should pass for aria-label (input)', function() {
+		var results = axe.runVirtualRule('label', {
+			nodeName: 'input',
+			attributes: {
+				'aria-label': 'foobar'
+			}
+		});
+
+		assert.lengthOf(results.passes, 1);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 0);
+	});
+
+	it('should pass for aria-label (textarea)', function() {
+		var results = axe.runVirtualRule('label', {
+			nodeName: 'textarea',
+			attributes: {
+				'aria-label': 'foobar'
+			}
+		});
+
+		assert.lengthOf(results.passes, 1);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 0);
+	});
+
+	it('should incomplete for aria-labelledby', function() {
+		var results = axe.runVirtualRule('label', {
+			nodeName: 'select',
+			attributes: {
+				'aria-labelledby': 'foobar'
+			}
+		});
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 1);
+	});
+
+	it('should pass for implicit label', function() {
+		var node = new axe.SerialVirtualNode({
+			nodeName: 'input'
+		});
+		var parent = new axe.SerialVirtualNode({
+			nodeName: 'label'
+		});
+		var child = new axe.SerialVirtualNode({
+			nodeName: '#text',
+			nodeType: 3,
+			nodeValue: 'foobar'
+		});
+		node.parent = parent;
+		parent.children = [child, node];
+
+		var results = axe.runVirtualRule('label', node);
+
+		assert.lengthOf(results.passes, 1);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 0);
+	});
+
+	it('should incomplete for explicit label', function() {
+		var node = new axe.SerialVirtualNode({
+			nodeName: 'input',
+			attributes: {
+				id: 'foobar'
+			}
+		});
+
+		var results = axe.runVirtualRule('label', node);
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 1);
+	});
+
+	it('should pass for title', function() {
+		var results = axe.runVirtualRule('label', {
+			nodeName: 'input',
+			attributes: {
+				title: 'foobar'
+			}
+		});
+
+		assert.lengthOf(results.passes, 1);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 0);
+	});
+
+	it('should incomplete for both missing aria-label and implicit label', function() {
+		var results = axe.runVirtualRule('label', {
+			nodeName: 'input',
+			attributes: {
+				'aria-label': ''
+			}
+		});
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 0);
+		assert.lengthOf(results.incomplete, 1);
+	});
+
+	it('should fail when aria-label contains only whitespace and no implicit label', function() {
+		var node = new axe.SerialVirtualNode({
+			nodeName: 'input',
+			attributes: {
+				'aria-label': ' \t   \n   '
+			}
+		});
+		node.parent = null;
+
+		var results = axe.runVirtualRule('label', node);
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 1);
+		assert.lengthOf(results.incomplete, 0);
+	});
+
+	it('should fail when aria-label is empty and no implicit label', function() {
+		var node = new axe.SerialVirtualNode({
+			nodeName: 'input',
+			attributes: {
+				'aria-label': ''
+			}
+		});
+		node.parent = null;
+
+		var results = axe.runVirtualRule('label', node);
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 1);
+		assert.lengthOf(results.incomplete, 0);
+	});
+
+	it('should fail when title is empty and no implicit label', function() {
+		var node = new axe.SerialVirtualNode({
+			nodeName: 'input',
+			attributes: {
+				title: ''
+			}
+		});
+		node.parent = null;
+
+		var results = axe.runVirtualRule('label', node);
+
+		assert.lengthOf(results.passes, 0);
+		assert.lengthOf(results.violations, 1);
+		assert.lengthOf(results.incomplete, 0);
+	});
+});
diff --git a/test/rule-matches/label-matches.js b/test/rule-matches/label-matches.js
index 338939c156..298aad8373 100644
--- a/test/rule-matches/label-matches.js
+++ b/test/rule-matches/label-matches.js
@@ -2,61 +2,46 @@ describe('label-matches', function() {
 	'use strict';
 
 	var fixture = document.getElementById('fixture');
+	var queryFixture = axe.testUtils.queryFixture;
 	var rule;
 
 	beforeEach(function() {
+		fixture.innerHTML = '';
 		rule = axe._audit.rules.find(function(rule) {
 			return rule.id === 'label';
 		});
 	});
 
 	it('returns true for non-input elements', function() {
-		fixture.innerHTML = '<textarea></textarea>';
-		var target = fixture.querySelector('textarea');
-
-		assert.isTrue(rule.matches(target));
+		var vNode = queryFixture('<textarea id="target"></textarea>');
+		assert.isTrue(rule.matches(null, vNode));
 	});
 
 	it('returns true for input elements without type', function() {
-		fixture.innerHTML = '<input />';
-		var target = fixture.querySelector('input');
+		var vNode = queryFixture('<input id="target" />');
 
-		assert.isTrue(rule.matches(target));
+		assert.isTrue(rule.matches(null, vNode));
 	});
 
 	it('returns false for input buttons', function() {
-		fixture.innerHTML =
-			'<input type="button" />' +
-			'<input type="submit" />' +
-			'<input type="image" />' +
-			'<input type="reset" />';
-
-		var targets = Array.from(fixture.querySelectorAll('input'));
-		targets.forEach(function(target) {
-			assert.isFalse(rule.matches(target));
+		['button', 'submit', 'image', 'reset'].forEach(function(type) {
+			var vNode = queryFixture('<input id="target" type="' + type + '" />');
+			assert.isFalse(rule.matches(null, vNode));
 		});
 	});
 
 	it('returns false for input elements type=hidden', function() {
-		fixture.innerHTML = '<input type="hidden" />';
-		var target = fixture.querySelector('input');
+		var vNode = queryFixture('<input id="target" type="hidden" />');
 
-		assert.isFalse(rule.matches(target));
+		assert.isFalse(rule.matches(null, vNode));
 	});
 
 	it('returns true for other input types', function() {
-		fixture.innerHTML =
-			'<input type="text" />' +
-			'<input type="password" />' +
-			'<input type="url" />' +
-			'<input type="range" />' +
-			'<input type="date" />' +
-			'<input type="checkbox" />' +
-			'<input type="radio" />';
-
-		var targets = Array.from(fixture.querySelectorAll('input'));
-		targets.forEach(function(target) {
-			assert.isTrue(rule.matches(target));
-		});
+		['text', 'password', 'url', 'range', 'date', 'checkbox', 'radio'].forEach(
+			function(type) {
+				var vNode = queryFixture('<input id="target" type="' + type + '" />');
+				assert.isTrue(rule.matches(null, vNode));
+			}
+		);
 	});
 });