diff --git a/tests/ve.qunit.js b/tests/ve.qunit.js
index a7a2dbe79..4bb3f0e0b 100644
--- a/tests/ve.qunit.js
+++ b/tests/ve.qunit.js
@@ -1,303 +1,303 @@
 /*!
  * VisualEditor plugin for QUnit.
  *
  * @copyright 2011-2017 VisualEditor Team and others; see http://ve.mit-license.org
  */
 
 /* global difflib,diffview */
 
 ( function ( QUnit ) {
 	/**
 	 * Plugin for QUnit.
 	 *
 	 * @class ve.QUnit
 	 * @extends QUnit
 	 */
 
 	/**
 	 * Builds a summary of a node tree.
 	 *
 	 * Generated summaries contain node types, lengths, outer lengths, attributes and summaries for
 	 * each child recursively. It's simple and fast to use deepEqual on this.
 	 *
 	 * @method
 	 * @private
 	 * @param {ve.Node} node Node tree to summarize
 	 * @param {boolean} [shallow] Do not summarize each child recursively
 	 * @return {Object} Summary of node tree
 	 */
 	function getNodeTreeSummary( node, shallow ) {
 		var i,
 			summary = {
 				getType: node.getType(),
 				getLength: node.getLength(),
 				getOuterLength: node.getOuterLength(),
 				element: node.element
 			},
 			numChildren;
 
 		if ( node.children !== undefined ) {
 			numChildren = node.children.length;
 			if ( !shallow ) {
 				summary.children = [];
 				for ( i = 0; i < numChildren; i++ ) {
 					summary.children.push( getNodeTreeSummary( node.children[ i ] ) );
 				}
 			}
 		}
 		return summary;
 	}
 
 	/**
 	 * Builds a summary of a node selection.
 	 *
 	 * Generated summaries contain length of results as well as node summaries, ranges, indexes, indexes
 	 * within parent and node ranges for each result. It's simple and fast to use deepEqual on this.
 	 *
 	 * @method
 	 * @private
 	 * @param {Object[]} selection Selection to summarize
 	 * @return {Object} Summary of selection
 	 */
 	function getNodeSelectionSummary( selection ) {
 		var i,
 			summary = {
 				length: selection.length
 			};
 
 		if ( selection.length ) {
 			summary.results = [];
 			for ( i = 0; i < selection.length; i++ ) {
 				summary.results.push( {
 					node: getNodeTreeSummary( selection[ i ].node, true ),
 					range: selection[ i ].range,
 					index: selection[ i ].index,
 					indexInNode: selection[ i ].indexInNode,
 					nodeRange: selection[ i ].nodeRange,
 					nodeOuterRange: selection[ i ].nodeOuterRange,
 					parentOuterRange: selection[ i ].parentOuterRange
 				} );
 			}
 		}
 		return summary;
 	}
 
 	/**
 	 * Callback for ve#copy to convert nodes to a comparable summary.
 	 *
 	 * @private
 	 * @param {ve.dm.Node|Object} value Value in the object/array
 	 * @return {Object} Node summary if value is a node, otherwise just the value
 	 */
 	function convertNodes( value ) {
 		return value instanceof ve.dm.Node || value instanceof ve.ce.Node ?
 			getNodeTreeSummary( value ) :
 			value;
 	}
 
 	/**
 	 * Undo what QUnit's escapeText does.
 	 *
 	 * @ignore
 	 * @param {string} s
 	 * @return {string}
 	 */
 	function unescapeText( s ) {
 		return s.replace( /&(#039|quot|lt|gt|amp);/g, function ( match, seq ) {
 			switch ( seq ) {
 				case '#039':
 					return '\'';
 				case 'quot':
 					return '"';
 				case 'lt':
 					return '<';
 				case 'gt':
 					return '>';
 				case 'amp':
 					return '&';
 			}
 		} );
 	}
 
 	/**
 	 * Assertion helpers for VisualEditor test suite.
 	 * @class ve.QUnit.assert
 	 */
 
 	/**
 	 * Assert that summaries of two node trees are equal.
 	 *
 	 * @method
 	 * @static
 	 * @param {ve.Node} actual
 	 * @param {ve.Node} expected
 	 * @param {boolean} shallow
 	 * @param {string} message
 	 */
 	QUnit.assert.equalNodeTree = function ( actual, expected, shallow, message ) {
 		var actualSummary, expectedSummary;
 		if ( typeof shallow === 'string' && arguments.length === 3 ) {
 			message = shallow;
 			shallow = undefined;
 		}
 		actualSummary = getNodeTreeSummary( actual, shallow );
 		expectedSummary = getNodeTreeSummary( expected, shallow );
 		QUnit.push(
 			QUnit.equiv( actualSummary, expectedSummary ), actualSummary, expectedSummary, message
 		);
 	};
 
 	/**
 	 * @method
 	 * @static
 	 * @param {Object[]} actual
 	 * @param {Object[]} expected
 	 * @param {string} message
 	 */
 	QUnit.assert.equalNodeSelection = function ( actual, expected, message ) {
 		var i,
 			actualSummary = getNodeSelectionSummary( actual ),
 			expectedSummary = getNodeSelectionSummary( expected );
 
 		for ( i = 0; i < actual.length; i++ ) {
 			if ( expected[ i ] && expected[ i ].node !== actual[ i ].node ) {
 				QUnit.push( false, actualSummary, expectedSummary,
 					message + ' (reference equality for selection[' + i + '].node)'
 				);
 				return;
 			}
 		}
 		QUnit.push(
 			QUnit.equiv( actualSummary, expectedSummary ), actualSummary, expectedSummary, message
 		);
 	};
 
 	/**
 	 * @method
 	 * @static
 	 * @param {HTMLElement} actual
 	 * @param {HTMLElement} expected
 	 * @param {string} message
 	 */
 	QUnit.assert.equalDomElement = function ( actual, expected, message ) {
 		var actualSummary = ve.getDomElementSummary( actual ),
 			expectedSummary = ve.getDomElementSummary( expected ),
 			actualSummaryHtml = ve.getDomElementSummary( actual, true ),
 			expectedSummaryHtml = ve.getDomElementSummary( expected, true );
 
 		QUnit.push(
 			QUnit.equiv( actualSummary, expectedSummary ), actualSummaryHtml, expectedSummaryHtml, message
 		);
 	};
 
 	QUnit.assert.equalLinearData = function ( actual, expected, message ) {
 		function removeOriginalDomElements( val ) {
 			if ( val && val.originalDomElementsIndex !== undefined ) {
 				delete val.originalDomElementsIndex;
 			}
 			if ( val && val.originalDomElements !== undefined ) {
 				delete val.originalDomElements;
 			}
 		}
 
 		actual = ve.copy( actual );
 		expected = ve.copy( expected );
 		actual = ve.copy( actual, null, removeOriginalDomElements );
 		expected = ve.copy( expected, null, removeOriginalDomElements );
 
 		QUnit.push( QUnit.equiv( actual, expected ), actual, expected, message );
 	};
 
 	QUnit.assert.equalLinearDataWithDom = function ( store, actual, expected, message ) {
 		function addOriginalDomElements( val ) {
 			if ( val && val.originalDomElementsIndex !== undefined ) {
 				val.originalDomElements = store.value( val.originalDomElementsIndex );
 				delete val.originalDomElementsIndex;
 			}
 		}
 
 		actual = ve.copy( actual );
 		expected = ve.copy( expected );
 		actual = ve.copy( actual, ve.convertDomElements, addOriginalDomElements );
 		expected = ve.copy( expected, ve.convertDomElements, addOriginalDomElements );
 
 		QUnit.push( QUnit.equiv( actual, expected ), actual, expected, message );
 	};
 
 	/**
 	 * Assert that two objects which may contain DOM elements are equal.
 	 *
 	 * @method
 	 * @static
 	 * @param {Object} actual
 	 * @param {Object} expected
 	 * @param {string} message
 	 */
 	QUnit.assert.deepEqualWithDomElements = function ( actual, expected, message ) {
 		// Recursively copy objects or arrays, converting any dom elements found to comparable summaries
 		actual = ve.copy( actual, ve.convertDomElements );
 		expected = ve.copy( expected, ve.convertDomElements );
 
 		QUnit.push( QUnit.equiv( actual, expected ), actual, expected, message );
 	};
 
 	/**
 	 * Assert that two objects which may contain node trees are equal.
 	 *
 	 * @method
 	 * @static
 	 * @param {Object} actual
 	 * @param {Object} expected
 	 * @param {string} message
 	 */
 	QUnit.assert.deepEqualWithNodeTree = function ( actual, expected, message ) {
 		// Recursively copy objects or arrays, converting any dom elements found to comparable summaries
 		actual = ve.copy( actual, convertNodes );
 		expected = ve.copy( expected, convertNodes );
 
 		QUnit.push( QUnit.equiv( actual, expected ), actual, expected, message );
 	};
 
 	QUnit.assert.equalRange = function ( actual, expected, message ) {
 		actual = actual && {
 			from: actual.from,
 			to: actual.to
 		};
 		expected = expected && {
 			from: expected.from,
 			to: expected.to
 		};
 		QUnit.push( QUnit.equiv( actual, expected ), actual, expected, message );
 	};
 
 	QUnit.assert.equalHash = function ( actual, expected, message ) {
-		actual = actual && actual.toJSON();
-		expected = expected && expected.toJSON();
+		actual = JSON.parse( JSON.stringify( actual ) );
+		expected = JSON.parse( JSON.stringify( expected ) );
 		QUnit.push( QUnit.equiv( actual, expected ), actual, expected, message );
 	};
 
 	QUnit.diff = function ( o, n ) {
 		// o and n are partially HTML escaped by QUnit. As difflib does
 		// its own escaping we should unescape them first.
 		var oLines = difflib.stringAsLines( unescapeText( o ) ),
 			nLines = difflib.stringAsLines( unescapeText( n ) ),
 			sm = new difflib.SequenceMatcher( oLines, nLines ),
 			// jscs:disable requireCamelCaseOrUpperCaseIdentifiers (awaiting eslint replacement; T149261)
 			opcodes = sm.get_opcodes(),
 			// jscs:enable requireCamelCaseOrUpperCaseIdentifiers
 			$div = $( '<div>' );
 
 		$div.append( diffview.buildView( {
 			baseTextLines: oLines,
 			newTextLines: nLines,
 			opcodes: opcodes,
 			baseTextName: 'Expected',
 			newTextName: 'Result',
 			contextSize: 10,
 			viewType: 0
 		} ) );
 
 		return $div.html();
 	};
 
 }( QUnit ) );