(function() {
	module("tinymce.html.DomParser");

	var schema = new tinymce.html.Schema({valid_elements: '*[class|title]'});
	var serializer = new tinymce.html.Serializer({}, schema);
	var parser, root;

	function countNodes(node, counter) {
		var sibling;

		if (!counter) {
			counter = {};
		}

		if (node.name in counter) {
			counter[node.name]++;
		} else {
			counter[node.name] = 1;
		}

		for (sibling = node.firstChild; sibling; sibling = sibling.next) {
			countNodes(sibling, counter);
		}

		return counter;
	}

	schema.addValidChildren('+body[style]');

	test('Parse element', function() {
		var parser, root;

		expect(7);

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<B title="title" class="class">test</B>');
		equal(serializer.serialize(root), '<b class="class" title="title">test</b>', 'Inline element');
		equal(root.firstChild.type, 1, 'Element type');
		equal(root.firstChild.name, 'b', 'Element name');
		deepEqual(root.firstChild.attributes, [{name: 'title', value: 'title'}, {name: 'class', value: 'class'}], 'Element attributes');
		deepEqual(countNodes(root), {body:1, b:1, '#text':1}, 'Element attributes (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <SCRIPT>  \t\r\n   a < b > \t\r\n   </S' + 'CRIPT>   \t\r\n  ');
		equal(serializer.serialize(root), '<script>  \t\r\n   a < b > \t\r\n   </s' + 'cript>', 'Retain code inside SCRIPT');
		deepEqual(countNodes(root), {body:1, script:1, '#text':1}, 'Retain code inside SCRIPT (count)');
	});

	test('Whitespace', function() {
		expect(12);

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <B>  \t\r\n   test  \t\r\n   </B>   \t\r\n  ');
		equal(serializer.serialize(root), ' <b> test </b> ', 'Redundant whitespace (inline element)');
		deepEqual(countNodes(root), {body:1, b:1, '#text':3}, 'Redundant whitespace (inline element) (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <P>  \t\r\n   test  \t\r\n   </P>   \t\r\n  ');
		equal(serializer.serialize(root), '<p>test</p>', 'Redundant whitespace (block element)');
		deepEqual(countNodes(root), {body:1, p:1, '#text':1}, 'Redundant whitespace (block element) (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <SCRIPT>  \t\r\n   test  \t\r\n   </S' + 'CRIPT>   \t\r\n  ');
		equal(serializer.serialize(root), '<script>  \t\r\n   test  \t\r\n   </s' + 'cript>', 'Whitespace around and inside SCRIPT');
		deepEqual(countNodes(root), {body:1, script:1, '#text':1}, 'Whitespace around and inside SCRIPT (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <STYLE>  \t\r\n   test  \t\r\n   </STYLE>   \t\r\n  ');
		equal(serializer.serialize(root), '<style>  \t\r\n   test  \t\r\n   </style>', 'Whitespace around and inside STYLE');
		deepEqual(countNodes(root), {body:1, style:1, '#text':1}, 'Whitespace around and inside STYLE (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<ul>\n<li>Item 1\n<ul>\n<li>\n \t Indented \t \n</li>\n</ul>\n</li>\n</ul>\n');
		equal(serializer.serialize(root), '<ul><li>Item 1<ul><li>Indented</li></ul></li></ul>', 'Whitespace around and inside blocks (ul/li)');
		deepEqual(countNodes(root), {body:1, li:2, ul:2, '#text':2}, 'Whitespace around and inside blocks (ul/li) (count)');

		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({invalid_elements : 'hr,br'}));
		root = parser.parse('\n<hr />\n<br />\n<div>\n<hr />\n<br />\n<img src="file.gif" data-mce-src="file.gif" />\n<hr />\n<br />\n</div>\n<hr />\n<br />\n');
		equal(serializer.serialize(root), '<div><img src="file.gif" data-mce-src="file.gif" /></div>', 'Whitespace where SaxParser will produce multiple whitespace nodes');
		deepEqual(countNodes(root), {body:1, div:1, img:1}, 'Whitespace where SaxParser will produce multiple whitespace nodes (count)');
	});

	test('Whitespace before/after invalid element with text in block', function() {
		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({invalid_elements : 'em'}));
		root = parser.parse('<p>a <em>b</em> c</p>');
		equal(serializer.serialize(root), '<p>a b c</p>');
	});

	test('Whitespace before/after invalid element whitespace element in block', function() {
		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({invalid_elements : 'span'}));
		root = parser.parse('<p> <span></span> </p>');
		equal(serializer.serialize(root), '<p>\u00a0</p>');
	});

	test('Whitespace preserved in PRE', function() {
		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <PRE>  \t\r\n   test  \t\r\n   </PRE>   \t\r\n  ');
		equal(serializer.serialize(root), '<pre>  \t\r\n   test  \t\r\n   </pre>', 'Whitespace around and inside PRE');
		deepEqual(countNodes(root), {body:1, pre:1, '#text':1}, 'Whitespace around and inside PRE (count)');
	});

	test('Whitespace preserved in PRE', function() {
		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<PRE>  </PRE>');
		equal(serializer.serialize(root), '<pre>  </pre>', 'Whitespace around and inside PRE');
		deepEqual(countNodes(root), {body:1, pre:1, '#text':1}, 'Whitespace around and inside PRE (count)');
	});

	test('Whitespace preserved in SPAN inside PRE', function() {
		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('  \t\r\n  <PRE>  \t\r\n  <span>    test    </span> \t\r\n   </PRE>   \t\r\n  ');
		equal(serializer.serialize(root), '<pre>  \t\r\n  <span>    test    </span> \t\r\n   </pre>', 'Whitespace around and inside PRE');
		deepEqual(countNodes(root), {body:1, pre:1, span:1, '#text':3}, 'Whitespace around and inside PRE (count)');
	});

	test('Whitespace preserved in code', function() {
		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<code>  a  </code>');
		equal(serializer.serialize(root), '<code>  a  </code>', 'Whitespace inside code');
		deepEqual(countNodes(root), {body:1, code:1, '#text':1}, 'Whitespace inside code (count)');
	});

	test('Whitespace preserved in code', function() {
		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<code>  </code>');
		equal(serializer.serialize(root), '<code>  </code>', 'Whitespace inside code');
		deepEqual(countNodes(root), {body:1, code:1, '#text':1}, 'Whitespace inside code (count)');
	});

	test('Parse invalid contents', function() {
		var parser, root;

		expect(20);

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a"><p class="b">123</p></p>');
		equal(serializer.serialize(root), '<p class="b">123</p>', 'P in P, no nodes before/after');
		deepEqual(countNodes(root), {body:1, p:1, '#text':1}, 'P in P, no nodes before/after (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a">a<p class="b">b</p><p class="c">c</p>d</p>');
		equal(serializer.serialize(root), '<p class="a">a</p><p class="b">b</p><p class="c">c</p><p class="a">d</p>', 'Two P in P, no nodes before/after');
		deepEqual(countNodes(root), {body: 1, p:4, '#text': 4}, 'Two P in P, no nodes before/after (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a">abc<p class="b">def</p></p>');
		equal(serializer.serialize(root), '<p class="a">abc</p><p class="b">def</p>', 'P in P with nodes before');
		deepEqual(countNodes(root), {body: 1, p:2, '#text': 2}, 'P in P with nodes before (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a"><p class="b">abc</p>def</p>');
		equal(serializer.serialize(root), '<p class="b">abc</p><p class="a">def</p>', 'P in P with nodes after');
		deepEqual(countNodes(root), {body: 1, p:2, '#text': 2}, 'P in P with nodes after (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a"><p class="b">abc</p><br></p>');
		equal(serializer.serialize(root), '<p class="b">abc</p>', 'P in P with BR after');
		deepEqual(countNodes(root), {body: 1, p:1, '#text': 1}, 'P in P with BR after (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a">a<strong>b<span>c<em>d<p class="b">e</p>f</em>g</span>h</strong>i</p>');
		equal(serializer.serialize(root), '<p class="a">a<strong>b<span>c<em>d</em></span></strong></p><p class="b">e</p><p class="a"><strong><span><em>f</em>g</span>h</strong>i</p>', 'P in P wrapped in inline elements');
		deepEqual(countNodes(root), {"body":1, "p":3, "#text":9, "strong":2, "span":2, "em": 2}, 'P in P wrapped in inline elements (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="a">a<p class="b">b<p class="c">c</p>d</p>e</p>');
		equal(serializer.serialize(root), '<p class="a">a</p><p class="b">b</p><p class="c">c</p><p class="b">d</p><p class="a">e</p>', 'P in P in P with text before/after');
		deepEqual(countNodes(root), {body: 1, p:5, '#text': 5}, 'P in P in P with text before/after (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p>a<ul><li>b</li><li>c</li></ul>d</p>');
		equal(serializer.serialize(root), '<p>a</p><ul><li>b</li><li>c</li></ul><p>d</p>', 'UL inside P');
		deepEqual(countNodes(root), {body: 1, p:2, ul:1, li:2, '#text': 4}, 'UL inside P (count)');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<table><tr><td><tr>a</tr></td></tr></table>');
		equal(serializer.serialize(root), '<table><tr><td>a</td></tr></table>', 'TR inside TD');
		deepEqual(countNodes(root), {body: 1, table:1, tr:1, td:1, '#text': 1}, 'TR inside TD (count)');

		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({valid_elements: 'p,section,div'}));
		root = parser.parse('<div><section><p>a</p></section></div>');
		equal(serializer.serialize(root), '<div><section><p>a</p></section></div>', 'P inside SECTION');
		deepEqual(countNodes(root), {"body":1, "div":1, "section":1, "p":1, "#text":1}, 'P inside SECTION (count)');
	});

	test('Remove empty nodes', function() {
		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({valid_elements: '-p,-span[id]'}));
		root = parser.parse('<p>a<span></span><span> </span><span id="x">b</span><span id="y"></span></p><p></p><p><span></span></p><p> </p>');
		equal(serializer.serialize(root), '<p>a <span id="x">b</span><span id="y"></span></p>');
	});

	test('addNodeFilter', function() {
		var parser, result;

		expect(7);

		parser = new tinymce.html.DomParser({}, schema);
		parser.addNodeFilter('#comment', function(nodes, name, args) {
			result = {nodes : nodes, name : name, args : args};
		});
		parser.parse('text<!--text1-->text<!--text2-->');

		deepEqual(result.args, {}, 'Parser args');
		equal(result.name, '#comment', 'Parser filter result name');
		equal(result.nodes.length, 2, 'Parser filter result node');
		equal(result.nodes[0].name, '#comment', 'Parser filter result node(0) name');
		equal(result.nodes[0].value, 'text1', 'Parser filter result node(0) value');
		equal(result.nodes[1].name, '#comment', 'Parser filter result node(1) name');
		equal(result.nodes[1].value, 'text2', 'Parser filter result node(1) value');
	});

	test('addNodeFilter multiple names', function() {
		var parser, results = {};

		expect(14);

		parser = new tinymce.html.DomParser({}, schema);
		parser.addNodeFilter('#comment,#text', function(nodes, name, args) {
			results[name] = {nodes : nodes, name : name, args : args};
		});
		parser.parse('text1<!--text1-->text2<!--text2-->');

		deepEqual(results['#comment'].args, {}, 'Parser args');
		equal(results['#comment'].name, '#comment', 'Parser filter result name');
		equal(results['#comment'].nodes.length, 2, 'Parser filter result node');
		equal(results['#comment'].nodes[0].name, '#comment', 'Parser filter result node(0) name');
		equal(results['#comment'].nodes[0].value, 'text1', 'Parser filter result node(0) value');
		equal(results['#comment'].nodes[1].name, '#comment', 'Parser filter result node(1) name');
		equal(results['#comment'].nodes[1].value, 'text2', 'Parser filter result node(1) value');
		deepEqual(results['#text'].args, {}, 'Parser args');
		equal(results['#text'].name, '#text', 'Parser filter result name');
		equal(results['#text'].nodes.length, 2, 'Parser filter result node');
		equal(results['#text'].nodes[0].name, '#text', 'Parser filter result node(0) name');
		equal(results['#text'].nodes[0].value, 'text1', 'Parser filter result node(0) value');
		equal(results['#text'].nodes[1].name, '#text', 'Parser filter result node(1) name');
		equal(results['#text'].nodes[1].value, 'text2', 'Parser filter result node(1) value');
	});

	test('addNodeFilter with parser args', function() {
		var parser, result;

		expect(1);

		parser = new tinymce.html.DomParser({}, schema);
		parser.addNodeFilter('#comment', function(nodes, name, args) {
			result = {nodes : nodes, name : name, args : args};
		});
		parser.parse('text<!--text1-->text<!--text2-->', {value: 1});

		deepEqual(result.args, {value: 1}, 'Parser args');
	});

	test('addAttributeFilter', function() {
		var parser, result;

		expect(7);

		parser = new tinymce.html.DomParser({});
		parser.addAttributeFilter('src', function(nodes, name, args) {
			result = {nodes : nodes, name : name, args : args};
		});
		parser.parse('<b>a<img src="1.gif" />b<img src="1.gif" />c</b>');

		deepEqual(result.args, {}, 'Parser args');
		equal(result.name, 'src', 'Parser filter result name');
		equal(result.nodes.length, 2, 'Parser filter result node');
		equal(result.nodes[0].name, 'img', 'Parser filter result node(0) name');
		equal(result.nodes[0].attr('src'), '1.gif', 'Parser filter result node(0) attr');
		equal(result.nodes[1].name, 'img', 'Parser filter result node(1) name');
		equal(result.nodes[1].attr('src'), '1.gif', 'Parser filter result node(1) attr');
	});

	test('addAttributeFilter multiple', function() {
		var parser, results = {};

		expect(14);

		parser = new tinymce.html.DomParser({});
		parser.addAttributeFilter('src,href', function(nodes, name, args) {
			results[name] = {nodes : nodes, name : name, args : args};
		});
		parser.parse('<b><a href="1.gif">a</a><img src="1.gif" />b<img src="1.gif" /><a href="2.gif">c</a></b>');

		deepEqual(results.src.args, {}, 'Parser args');
		equal(results.src.name, 'src', 'Parser filter result name');
		equal(results.src.nodes.length, 2, 'Parser filter result node');
		equal(results.src.nodes[0].name, 'img', 'Parser filter result node(0) name');
		equal(results.src.nodes[0].attr('src'), '1.gif', 'Parser filter result node(0) attr');
		equal(results.src.nodes[1].name, 'img', 'Parser filter result node(1) name');
		equal(results.src.nodes[1].attr('src'), '1.gif', 'Parser filter result node(1) attr');
		deepEqual(results.href.args, {}, 'Parser args');
		equal(results.href.name, 'href', 'Parser filter result name');
		equal(results.href.nodes.length, 2, 'Parser filter result node');
		equal(results.href.nodes[0].name, 'a', 'Parser filter result node(0) name');
		equal(results.href.nodes[0].attr('href'), '1.gif', 'Parser filter result node(0) attr');
		equal(results.href.nodes[1].name, 'a', 'Parser filter result node(1) name');
		equal(results.href.nodes[1].attr('href'), '2.gif', 'Parser filter result node(1) attr');
	});

	test('Fix orphan LI elements', function() {
		var parser;

		expect(3);

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<ul><li>a</li></ul><li>b</li>');
		equal(serializer.serialize(root), '<ul><li>a</li><li>b</li></ul>', 'LI moved to previous sibling UL');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<li>a</li><ul><li>b</li></ul>');
		equal(serializer.serialize(root), '<ul><li>a</li><li>b</li></ul>', 'LI moved to next sibling UL');

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<li>a</li>');
		equal(serializer.serialize(root), '<ul><li>a</li></ul>', 'LI wrapped in new UL');
	});

	test('Remove empty elements', function() {
		var parser, schema = new tinymce.html.Schema({valid_elements: 'span,-a,img'});

		expect(3);

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<span></span><a href="#"></a>');
		equal(serializer.serialize(root), '<span></span>', 'Remove empty a element');

		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({valid_elements: 'span,a[name],img'}));
		root = parser.parse('<span></span><a name="anchor"></a>');
		equal(serializer.serialize(root), '<span></span><a name="anchor"></a>', 'Leave a with name attribute');

		parser = new tinymce.html.DomParser({}, new tinymce.html.Schema({valid_elements: 'span,a[href],img[src]'}));
		root = parser.parse('<span></span><a href="#"><img src="about:blank" /></a>');
		equal(serializer.serialize(root), '<span></span><a href="#"><img src="about:blank" /></a>', 'Leave elements with img in it');
	});

	test('Self closing list elements', function() {
		var parser, root, schema = new tinymce.html.Schema();

		expect(1);

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<ul><li>1<li><b>2</b><li><em><b>3</b></em></ul>');
		equal(serializer.serialize(root), '<ul><li>1</li><li><strong>2</strong></li><li><em><strong>3</strong></em></li></ul>', 'Split out LI elements in LI elements.');
	});

	test('Remove redundant br elements', function() {
		var parser, root, schema = new tinymce.html.Schema();

		expect(1);

		parser = new tinymce.html.DomParser({remove_trailing_brs : true}, schema);
		root = parser.parse(
			'<p>a<br></p>' +
			'<p>a<br>b<br></p>' +
			'<p>a<br><br></p><p>a<br><span data-mce-type="bookmark"></span><br></p>' +
			'<p>a<span data-mce-type="bookmark"></span><br></p>'
		);
		equal(serializer.serialize(root), '<p>a</p><p>a<br />b</p><p>a<br /><br /></p><p>a<br /><br /></p><p>a</p>', 'Remove traling br elements.');
	});

	test('Replace br with nbsp when wrapped in two inline elements and one block', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({remove_trailing_brs : true}, schema);
		root = parser.parse('<p><strong><em><br /></em></strong></p>');
		equal(serializer.serialize(root), '<p><strong><em>\u00a0</em></strong></p>');
	});

	test('Replace br with nbsp when wrapped in an inline element and placed in the root', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({remove_trailing_brs : true}, schema);
		root = parser.parse('<strong><br /></strong>');
		equal(serializer.serialize(root), '<strong>\u00a0</strong>');
	});

	test('Don\'t replace br inside root element when there is multiple brs', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({remove_trailing_brs : true}, schema);
		root = parser.parse('<strong><br /><br /></strong>');
		equal(serializer.serialize(root), '<strong><br /><br /></strong>');
	});

	test('Don\'t replace br inside root element when there is siblings', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({remove_trailing_brs : true}, schema);
		root = parser.parse('<strong><br /></strong><em>x</em>');
		equal(serializer.serialize(root), '<strong><br /></strong><em>x</em>');
	});

	test('Remove br in invalid parent bug', function() {
		var parser, root, schema = new tinymce.html.Schema({valid_elements: 'br'});

		expect(1);

		parser = new tinymce.html.DomParser({remove_trailing_brs : true}, schema);
		root = parser.parse('<br>');
		equal(serializer.serialize(root), '', 'Remove traling br elements.');
	});

	test('Forced root blocks', function() {
		var parser, root, schema = new tinymce.html.Schema();

		expect(1);

		parser = new tinymce.html.DomParser({forced_root_block : 'p'}, schema);
		root = parser.parse(
			'<!-- a -->' +
			'b' +
			'<b>c</b>' +
			'<p>d</p>' +
			'<p>e</p>' +
			'f' +
			'<b>g</b>' +
			'h'
		);
		equal(serializer.serialize(root), '<!-- a --><p>b<strong>c</strong></p><p>d</p><p>e</p><p>f<strong>g</strong>h</p>', 'Mixed text nodes, inline elements and blocks.');
	});

	test('Forced root blocks attrs', function() {
		var parser, root, schema = new tinymce.html.Schema();

		expect(1);

		parser = new tinymce.html.DomParser({forced_root_block: 'p', forced_root_block_attrs: {"class": "class1"}}, schema);
		root = parser.parse(
			'<!-- a -->' +
			'b' +
			'<b>c</b>' +
			'<p>d</p>' +
			'<p>e</p>' +
			'f' +
			'<b>g</b>' +
			'h'
		);
		equal(serializer.serialize(root), '<!-- a -->' +
			'<p class="class1">b<strong>c</strong></p>' +
			'<p>d</p>' +
			'<p>e</p>' +
			'<p class="class1">f<strong>g</strong>h</p>',
		'Mixed text nodes, inline elements and blocks.');
	});

	test('Parse html4 lists into html5 lists', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({fix_list_elements: true}, schema);
		root = parser.parse('<ul><ul><li>a</li></ul></ul><ul><li>a</li><ul><li>b</li></ul></ul>');
		equal(serializer.serialize(root), '<ul><li style="list-style-type: none"><ul><li>a</li></ul></li></ul><ul><li>a<ul><li>b</li></ul></li></ul>');
	});

	test('Parse contents with html4 anchors and allow_html_in_named_anchor: false', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({allow_html_in_named_anchor : false}, schema);
		root = parser.parse('<a name="x">a</a><a href="x">x</a>');
		equal(serializer.serialize(root), '<a name="x"></a>a<a href="x">x</a>');
	});

	test('Parse contents with html5 anchors and allow_html_in_named_anchor: false', function() {
		var parser, root, schema = new tinymce.html.Schema({schema: "html5"});

		parser = new tinymce.html.DomParser({allow_html_in_named_anchor : false}, schema);
		root = parser.parse('<a id="x">a</a><a href="x">x</a>');
		equal(serializer.serialize(root), '<a id="x"></a>a<a href="x">x</a>');
	});

	test('Parse contents with html4 anchors and allow_html_in_named_anchor: true', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({allow_html_in_named_anchor : true}, schema);
		root = parser.parse('<a name="x">a</a><a href="x">x</a>');
		equal(serializer.serialize(root), '<a name="x">a</a><a href="x">x</a>');
	});

	test('Parse contents with html5 anchors and allow_html_in_named_anchor: true', function() {
		var parser, root, schema = new tinymce.html.Schema({schema: "html5"});

		parser = new tinymce.html.DomParser({allow_html_in_named_anchor : true}, schema);
		root = parser.parse('<a id="x">a</a><a href="x">x</a>');
		equal(serializer.serialize(root), '<a id="x">a</a><a href="x">x</a>');
	});

	test('Parse contents with html5 self closing datalist options', function() {
		var parser, root, schema = new tinymce.html.Schema({schema: "html5"});

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<datalist><option label="a1" value="b1"><option label="a2" value="b2"><option label="a3" value="b3"></datalist>');
		equal(serializer.serialize(root), '<datalist><option label="a1" value="b1"></option><option label="a2" value="b2"></option><option label="a3" value="b3"></option></datalist>');
	});

	test('Parse inline contents before block bug #5424', function() {
		var parser, root, schema = new tinymce.html.Schema({schema: "html5"});

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<b>1</b> 2<p>3</p>');
		equal(serializer.serialize(root), '<b>1</b> 2<p>3</p>');
	});

	test('Invalid text blocks within a li', function() {
		var parser, root, schema = new tinymce.html.Schema({schema: "html5", valid_children: '-li[p]'});

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<ul><li>1<p>2</p></li><li>a<p>b</p><p>c</p></li></ul>');
		equal(serializer.serialize(root), '<ul><li>12</li><li>ab</li><li>c</li></ul>');
	});

	test('Invalid inline element with space before', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p><span>1</span> <strong>2</strong></p>');
		equal(serializer.serialize(root), '<p>1 <strong>2</strong></p>');
	});

	test('Valid classes', function() {
		var parser, root, schema = new tinymce.html.Schema({valid_classes: 'classA classB'});

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="classA classB classC">a</p>');
		equal(serializer.serialize(root), '<p class="classA classB">a</p>');
	});

	test('Valid classes multiple elements', function() {
		var parser, root, schema = new tinymce.html.Schema({valid_classes: {'*': 'classA classB', 'strong': 'classC'}});

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<p class="classA classB classC"><strong class="classA classB classC classD">a</strong></p>');
		equal(serializer.serialize(root), '<p class="classA classB"><strong class="classA classB classC">a</strong></p>');
	});

	test('Remove empty list blocks', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('<ul><li></li></ul><ul><li> </li></ul>');
		equal(serializer.serialize(root), '');
	});

	test('Padd empty with br', function() {
		var schema = new tinymce.html.Schema();
		var parser = new tinymce.html.DomParser({padd_empty_with_br: true}, schema);
		var serializer = new tinymce.html.Serializer({padd_empty_with_br: true}, schema);
		var root = parser.parse('<p>a</p><p></p>');
		equal(serializer.serialize(root), '<p>a</p><p><br /></p>');
	});

	test('Preserve space in inline span', function() {
		var parser, root, schema = new tinymce.html.Schema();

		parser = new tinymce.html.DomParser({}, schema);
		root = parser.parse('a<span> </span>b');
		equal(serializer.serialize(root), 'a b');
	});

	test('Bug #7543 removes whitespace between bogus elements before a block', function() {
		var serializer = new tinymce.html.Serializer();

		equal(
			serializer.serialize(new tinymce.html.DomParser().parse(
				'<div><b data-mce-bogus="1">a</b> <b data-mce-bogus="1">b</b><p>c</p></div>')
			),
			'<div>a b<p>c</p></div>'
		);
	});

	test('Bug #7582 removes whitespace between bogus elements before a block', function() {
		var serializer = new tinymce.html.Serializer();

		equal(
			serializer.serialize(new tinymce.html.DomParser().parse(
				'<div>1 <span data-mce-bogus="1">2</span><div>3</div></div>')
			),
			'<div>1 2<div>3</div></div>'
		);
	});
})();
