Adding PHP BlockTests. Normalizing all assertions to expected,actual ordering. Better normalization of HTML whitespace in tests

jstest/BlockTests.js

 
 	test_paragraphs() {
 		let markdown = "Lorem ipsum\n\nDolor sit amet";
-		let expected = "<p>Lorem ipsum</p> <p>Dolor sit amet</p>";
+		let expected = "<p>Lorem ipsum</p><p>Dolor sit amet</p>";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_paragraph_lineGrouping() {
 		let markdown = "Lorem ipsum\ndolor sit amet";
 		let expected = "Lorem ipsum dolor sit amet";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_header_underlineH1() {
 		let markdown = "Header 1\n===\n\nLorem ipsum";
-		let expected = "<h1>Header 1</h1> <p>Lorem ipsum</p>";
+		let expected = "<h1>Header 1</h1><p>Lorem ipsum</p>";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_header_underlineH2() {
 		let markdown = "Header 2\n---\n\nLorem ipsum";
-		let expected = "<h2>Header 2</h2> <p>Lorem ipsum</p>";
+		let expected = "<h2>Header 2</h2><p>Lorem ipsum</p>";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_header_hash() {
 		let markdown = "# Header 1\n## Header 2\n### Header 3\n#### Header 4\n##### Header 5\n###### Header 6\n";
-		let expected = '<h1>Header 1</h1> <h2>Header 2</h2> <h3>Header 3</h3> <h4>Header 4</h4> <h5>Header 5</h5> <h6>Header 6</h6>';
+		let expected = '<h1>Header 1</h1><h2>Header 2</h2><h3>Header 3</h3><h4>Header 4</h4><h5>Header 5</h5><h6>Header 6</h6>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_header_hash_trailing() {
 		let markdown = "# Header 1 #\n## Header 2 ##\n### Header 3 ######";
-		let expected = '<h1>Header 1</h1> <h2>Header 2</h2> <h3>Header 3</h3>';
+		let expected = '<h1>Header 1</h1><h2>Header 2</h2><h3>Header 3</h3>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_unorderedList() {
 		let markdown = "* Lorem\n* Ipsum\n* Dolor";
-		let expected = '<ul> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ul>';
+		let expected = '<ul><li>Lorem</li><li>Ipsum</li><li>Dolor</li></ul>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_unorderedList_nested() {
 		let markdown = "* Lorem\n + Ipsum\n* Dolor";
-		let expected = '<ul> <li>Lorem<ul> <li>Ipsum</li> </ul> </li> <li>Dolor</li> </ul>';
+		let expected = '<ul><li>Lorem<ul><li>Ipsum</li></ul></li><li>Dolor</li></ul>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_unorderedList_hitch() {
 		// point, not forever but a REALLY long time
 		this.profile(1.0, () => {
 			let markdown = "Testing\n\n* ";
-			let expected = '<p>Testing</p> <ul> <li></li> </ul>';
+			let expected = '<p>Testing</p><ul><li></li></ul>';
 			let actual = this.md(markdown);
-			this.assertEqual(actual, expected);
+			this.assertEqual(expected, actual);
 		});
 	}
 
 	test_orderedList() {
 		let markdown = "1. Lorem\n1. Ipsum\n5. Dolor";
-		let expected = '<ol> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ol>';
+		let expected = '<ol><li>Lorem</li><li>Ipsum</li><li>Dolor</li></ol>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_orderedList_numbering() {
 		let markdown = "4. Lorem\n1. Ipsum\n9. Dolor";
-		let expected = '<ol start="4"> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ol>';
+		let expected = '<ol start="4"><li>Lorem</li><li>Ipsum</li><li>Dolor</li></ol>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_orderedList_nested1() {
 		let markdown = "1. Lorem\n 1. Ipsum\n1. Dolor";
-		let expected = '<ol> <li>Lorem<ol> <li>Ipsum</li> </ol> </li> <li>Dolor</li> </ol>';
+		let expected = '<ol><li>Lorem<ol><li>Ipsum</li></ol></li><li>Dolor</li></ol>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_orderedList_nested2() {
 		let markdown = "1. Lorem\n 1. Ipsum\n      1. Dolor\n 1. Sit\n1. Amet";
-		let expected = '<ol> <li>Lorem<ol> <li>Ipsum<ol> <li>Dolor</li> </ol> </li> <li>Sit</li> </ol> </li> <li>Amet</li> </ol>';
+		let expected = '<ol><li>Lorem<ol><li>Ipsum<ol><li>Dolor</li></ol></li><li>Sit</li></ol></li><li>Amet</li></ol>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_blockquote() {
 		let markdown = '> Lorem ipsum dolor';
 		let expected = '<blockquote>Lorem ipsum dolor</blockquote>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_blockquote_paragraphs() {
 		let markdown = '> Lorem ipsum dolor\n>\n>Sit amet';
-		let expected = '<blockquote> <p>Lorem ipsum dolor</p> <p>Sit amet</p> </blockquote>';
+		let expected = '<blockquote><p>Lorem ipsum dolor</p><p>Sit amet</p></blockquote>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_blockquote_list() {
 		let markdown = '> 1. Lorem\n> 2. Ipsum';
-		let expected = '<blockquote> <ol> <li>Lorem</li> <li>Ipsum</li> </ol> </blockquote>';
+		let expected = '<blockquote><ol><li>Lorem</li><li>Ipsum</li></ol></blockquote>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_codeBlock_indented() {
 		let markdown = "Code\n\n    function foo() {\n        return 'bar';\n    }\n\nend";
 		let expected = "<p>Code</p>\n\n<pre><code>function foo() {\n    return 'bar';\n}</code></pre>\n\n<p>end</p>";
 		let actual = this.parser.toHTML(markdown).trim(); // don't normalize whitespace
-		this.assertEqual(actual.replace(/ /g, '⎵'), expected.replace(/ /g, '⎵'));
+		this.assertEqual(expected.replace(/ /g, '⎵'), actual.replace(/ /g, '⎵'));
 	}
 
 	test_codeBlock_fenced() {
 		let markdown = "Code\n\n```\nfunction foo() {\n    return 'bar';\n}\n```\n\nend";
 		let expected = "<p>Code</p>\n\n<pre><code>function foo() {\n    return 'bar';\n}</code></pre>\n\n<p>end</p>";
 		let actual = this.parser.toHTML(markdown).trim(); // don't normalize whitespace
-		this.assertEqual(actual.replace(/ /g, '⎵'), expected.replace(/ /g, '⎵'));
+		this.assertEqual(expected.replace(/ /g, '⎵'), actual.replace(/ /g, '⎵'));
 	}
 
 	test_codeBlock_fenced_language() {
 		let markdown = "Code\n\n```javascript\nfunction foo() {\n    return 'bar';\n}\n```\n\nend";
 		let expected = "<p>Code</p>\n\n<pre><code class=\"language-javascript\">function foo() {\n    return 'bar';\n}</code></pre>\n\n<p>end</p>";
 		let actual = this.parser.toHTML(markdown).trim(); // don't normalize whitespace
-		this.assertEqual(actual.replace(/ /g, '⎵'), expected.replace(/ /g, '⎵'));
+		this.assertEqual(expected.replace(/ /g, '⎵'), actual.replace(/ /g, '⎵'));
 	}
 
 	test_horizontalRule() {
 		let markdown = "Before\n\n---\n\n- - -\n\n***\n\n* * * * * * *\n\nafter";
-		let expected = "<p>Before</p> <hr> <hr> <hr> <hr> <p>after</p>";
+		let expected = "<p>Before</p><hr><hr><hr><hr><p>after</p>";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_table_unfenced() {
 		let markdown = "Column A | Column B | Column C\n--- | --- | ---\n1 | 2 | 3\n4 | 5 | 6";
-		let expected = "<table> <thead> <tr> <th>Column A</th> <th>Column B</th> <th>Column C</th> </tr> </thead> <tbody> <tr> <td>1</td> <td>2</td> <td>3</td> </tr> <tr> <td>4</td> <td>5</td> <td>6</td> </tr> </tbody> </table>";
+		let expected = "<table><thead><tr><th>Column A</th><th>Column B</th><th>Column C</th></tr></thead><tbody><tr><td>1</td><td>2</td><td>3</td></tr><tr><td>4</td><td>5</td><td>6</td></tr></tbody></table>";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_table_fenced() {
 		let markdown = "| Column A | Column B | Column C |\n| --- | --- | --- |\n| 1 | 2 | 3\n4 | 5 | 6 |";
-		let expected = "<table> <thead> <tr> <th>Column A</th> <th>Column B</th> <th>Column C</th> </tr> </thead> <tbody> <tr> <td>1</td> <td>2</td> <td>3</td> </tr> <tr> <td>4</td> <td>5</td> <td>6</td> </tr> </tbody> </table>";
+		let expected = "<table><thead><tr><th>Column A</th><th>Column B</th><th>Column C</th></tr></thead><tbody><tr><td>1</td><td>2</td><td>3</td></tr><tr><td>4</td><td>5</td><td>6</td></tr></tbody></table>";
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_table_alignment() {
 			':--- | :---: | ---:\n' +
 			'1 | 2 | 3\n' +
 			'4 | 5 | 6';
-		let expected = '<table> ' +
-			'<thead> ' +
-			'<tr> ' +
-			'<th style="text-align: left;">Column A</th> ' +
-			'<th style="text-align: center;">Column B</th> ' +
-			'<th style="text-align: right;">Column C</th> ' +
-			'</tr> ' +
-			'</thead> ' +
-			'<tbody> ' +
-			'<tr> ' +
-			'<td style="text-align: left;">1</td> ' +
-			'<td style="text-align: center;">2</td> ' +
-			'<td style="text-align: right;">3</td> ' +
-			'</tr> ' +
-			'<tr> ' +
-			'<td style="text-align: left;">4</td> ' +
-			'<td style="text-align: center;">5</td> ' +
-			'<td style="text-align: right;">6</td> ' +
-			'</tr> ' +
-			'</tbody> ' +
+		let expected = '<table>' +
+			'<thead>' +
+			'<tr>' +
+			'<th style="text-align: left;">Column A</th>' +
+			'<th style="text-align: center;">Column B</th>' +
+			'<th style="text-align: right;">Column C</th>' +
+			'</tr>' +
+			'</thead>' +
+			'<tbody>' +
+			'<tr>' +
+			'<td style="text-align: left;">1</td>' +
+			'<td style="text-align: center;">2</td>' +
+			'<td style="text-align: right;">3</td>' +
+			'</tr>' +
+			'<tr>' +
+			'<td style="text-align: left;">4</td>' +
+			'<td style="text-align: center;">5</td>' +
+			'<td style="text-align: right;">6</td>' +
+			'</tr>' +
+			'</tbody>' +
 			'</table>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_table_holes() {
 			'|1|2||\n' +
 			'|4||6|\n' +
 			'||8|9|';
-		let expected = '<table> ' +
-			'<thead> ' +
-			'<tr> ' +
-			'<th>Column A</th> ' +
-			'<th></th> ' +
-			'<th>Column C</th> ' +
-			'</tr> ' +
-			'</thead> ' +
-			'<tbody> ' +
-			'<tr> ' +
-			'<td>1</td> ' +
-			'<td>2</td> ' +
-			'<td></td> ' +
-			'</tr> ' +
-			'<tr> ' +
-			'<td>4</td> ' +
-			'<td></td> ' +
-			'<td>6</td> ' +
-			'</tr> ' +
-			'<tr> ' +
-			'<td></td> ' +
-			'<td>8</td> ' +
-			'<td>9</td> ' +
-			'</tr> ' +
-			'</tbody> ' +
+		let expected = '<table>' +
+			'<thead>' +
+			'<tr>' +
+			'<th>Column A</th>' +
+			'<th></th>' +
+			'<th>Column C</th>' +
+			'</tr>' +
+			'</thead>' +
+			'<tbody>' +
+			'<tr>' +
+			'<td>1</td>' +
+			'<td>2</td>' +
+			'<td></td>' +
+			'</tr>' +
+			'<tr>' +
+			'<td>4</td>' +
+			'<td></td>' +
+			'<td>6</td>' +
+			'</tr>' +
+			'<tr>' +
+			'<td></td>' +
+			'<td>8</td>' +
+			'<td>9</td>' +
+			'</tr>' +
+			'</tbody>' +
 			'</table>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_definitionList() {
 			': def 1\n' +
 			' broken on next line\n' +
 			': def 2';
-		let expected = '<dl> ' +
-			'<dt>term</dt> ' +
-			'<dd>definition</dd> ' +
-			'<dt>another term</dt> ' +
-			'<dd>def 1 broken on next line</dd> ' +
-			'<dd>def 2</dd> ' +
+		let expected = '<dl>' +
+			'<dt>term</dt>' +
+			'<dd>definition</dd>' +
+			'<dt>another term</dt>' +
+			'<dd>def 1 broken on next line</dd>' +
+			'<dd>def 2</dd>' +
 			'</dl>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_footnotes() {
 		let markdown = 'Lorem ipsum[^1] dolor[^abc] sit[^1] amet\n\n[^1]: A footnote\n[^abc]: Another footnote';
 		let expected = '<p>Lorem ipsum<sup class="footnote" id="footnoteref_1"><a href="#footnote_1">1</a></sup> ' +
 			'dolor<sup class="footnote" id="footnoteref_2"><a href="#footnote_2">2</a></sup> ' +
-			'sit<sup class="footnote" id="footnoteref_3"><a href="#footnote_1">1</a></sup> amet</p> ' +
+			'sit<sup class="footnote" id="footnoteref_3"><a href="#footnote_1">1</a></sup> amet</p>' +
 			'<div class="footnotes">' +
 			'<ol>' +
-			'<li value="1" id="footnote_1">A footnote <a href="#footnoteref_1" class="footnote-backref">↩︎</a> <a href="#footnoteref_3" class="footnote-backref">↩︎</a></li> ' +
-			'<li value="2" id="footnote_2">Another footnote <a href="#footnoteref_2" class="footnote-backref">↩︎</a></li> ' +
+			'<li value="1" id="footnote_1">A footnote <a href="#footnoteref_1" class="footnote-backref">↩︎</a><a href="#footnoteref_3" class="footnote-backref">↩︎</a></li>' +
+			'<li value="2" id="footnote_2">Another footnote <a href="#footnoteref_2" class="footnote-backref">↩︎</a></li>' +
 			'</ol>' +
 			'</div>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_abbreviations() {
 			'*[HTML]: Hypertext Markup Language';
 		let expected = '<p>Lorem ipsum <abbr title="Hypertext Markup Language">HTML</abbr> dolor <abbr title="Hypertext Markup Language">HTML</abbr> sit</p>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 }

jstest/InlineTests.js

 		let markdown = 'Lorem ipsum';
 		let expected = 'Lorem ipsum';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strong() {
 		let markdown = 'Lorem **ipsum** dolor **sit**';
 		let expected = 'Lorem <strong>ipsum</strong> dolor <strong>sit</strong>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_emphasis() {
 		let markdown = 'Lorem _ipsum_ dolor _sit_';
 		let expected = 'Lorem <em>ipsum</em> dolor <em>sit</em>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_cleanNesting1() {
 		let markdown = 'Lorem **ipsum *dolor* sit** amet';
 		let expected = 'Lorem <strong>ipsum <em>dolor</em> sit</strong> amet';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_cleanNesting2() {
 		let markdown = 'Lorem *ipsum **dolor** sit* amet';
 		let expected = 'Lorem <em>ipsum <strong>dolor</strong> sit</em> amet';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_tightNesting() {
 		let markdown = 'Lorem ***ipsum*** dolor';
 		let expected = 'Lorem <strong><em>ipsum</em></strong> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_lopsidedNesting1() {
 		let markdown = 'Lorem ***ipsum* dolor** sit';
 		let expected = 'Lorem <strong><em>ipsum</em> dolor</strong> sit';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_lopsidedNesting2() {
 		let markdown = 'Lorem ***ipsum** dolor* sit';
 		let expected = 'Lorem <em><strong>ipsum</strong> dolor</em> sit';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_lopsidedNesting3() {
 		let markdown = 'Lorem **ipsum *dolor*** sit';
 		let expected = 'Lorem <strong>ipsum <em>dolor</em></strong> sit';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strongEmphasis_lopsidedNesting4() {
 		let markdown = 'Lorem *ipsum **dolor*** sit';
 		let expected = 'Lorem <em>ipsum <strong>dolor</strong></em> sit';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_inlineCode() {
 		let markdown = 'Lorem `ipsum` dolor';
 		let expected = 'Lorem <code>ipsum</code> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_inlineCode_withInnerBacktick() {
 		let markdown = 'Lorem ``ip`su`m`` dolor';
 		let expected = 'Lorem <code>ip`su`m</code> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_strikethrough_double() {
 		let markdown = 'Lorem ~~ipsum~~ dolor';
 		let expected = 'Lorem <s>ipsum</s> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_subscript() {
 		let markdown = 'H~2~O';
 		let expected = 'H<sub>2</sub>O';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_superscript() {
 		let markdown = 'E=mc^2^';
 		let expected = 'E=mc<sup>2</sup>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_highlight() {
 		let markdown = 'Lorem ==ipsum== dolor';
 		let expected = 'Lorem <mark>ipsum</mark> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_underline() {
 		let markdown = 'Lorem __ipsum__ dolor';
 		let expected = 'Lorem <u>ipsum</u> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_fullyQualified() {
 		let markdown = 'Lorem [ipsum](https://example.com/path/page.html) dolor';
 		let expected = 'Lorem <a href="https://example.com/path/page.html">ipsum</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_relative() {
 		let markdown = 'Lorem [ipsum](page.html) dolor';
 		let expected = 'Lorem <a href="page.html">ipsum</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_title() {
 		let markdown = 'Lorem [ipsum](page.html "link title") dolor';
 		let expected = 'Lorem <a href="page.html" title="link title">ipsum</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_literal() {
 		let markdown = 'Lorem <https://example.com> dolor';
 		let expected = 'Lorem <a href="https://example.com">https://example.com</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_ref() {
 		let markdown = "Lorem [ipsum][ref] dolor\n\n[ref]: https://example.com";
 		let expected = '<p>Lorem <a href="https://example.com">ipsum</a> dolor</p>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_email() {
 		let markdown = 'Lorem [ipsum](user@example.com) dolor';
 		let expected = 'Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">ipsum</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_email_withTitle() {
 		let markdown = 'Lorem [ipsum](user@example.com "title") dolor';
 		let expected = 'Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;" title="title">ipsum</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_literalEmail() {
 		let markdown = 'Lorem <user@example.com> dolor';
 		let expected = 'Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;</a> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_image() {
 		let markdown = 'Lorem [![alt](image.jpg)](page.html) ipsum';
 		let expected = 'Lorem <a href="page.html"><img src="image.jpg" alt="alt"></a> ipsum';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_link_image_complex() {
 		let markdown = 'Lorem [![alt] (image.jpg "image title")] (page.html "link title") ipsum';
 		let expected = 'Lorem <a href="page.html" title="link title"><img src="image.jpg" alt="alt" title="image title"></a> ipsum';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_image() {
 		let markdown = 'Lorem ![alt text](image.jpg) dolor';
 		let expected = 'Lorem <img src="image.jpg" alt="alt text"> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_image_noAlt() {
 		let markdown = 'Lorem ![](image.jpg) dolor';
 		let expected = 'Lorem <img src="image.jpg"> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_image_withTitle() {
 		let markdown = 'Lorem ![alt text](image.jpg "image title") dolor';
 		let expected = 'Lorem <img src="image.jpg" alt="alt text" title="image title"> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_image_ref() {
 			'[ref]: image.jpg "image title"';
 		let expected = '<p>Lorem <img src="image.jpg" alt="alt text" title="image title"> dolor</p>';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_htmlTags() {
 		let markdown = 'Lorem <strong title=\'with " quote\' id="with \' apostrophe" lang=unquoted translate forbidden="true">ipsum</strong> dolor';
 		let expected = 'Lorem <strong title="with &quot; quote" id="with \' apostrophe" lang="unquoted" translate>ipsum</strong> dolor';
 		let actual = this.md(markdown);
-		this.assertEqual(actual, expected);
+		this.assertEqual(expected, actual);
 	}
 }

jstest/TokenTests.js

 		const pattern = [
 			MDTokenType.Underscore,
 		];
-		const result = MDToken.findFirstTokens(tokens, pattern);
+		const actual = MDToken.findFirstTokens(tokens, pattern);
 		const expected = {
 			tokens: [ tokens[2] ],
 			index: 2,
 		};
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_findFirstTokens_optionalWhitespace1() {
 			MDTokenType.META_OptionalWhitespace,
 			MDTokenType.URL,
 		];
-		const result = MDToken.findFirstTokens(tokens, pattern);
+		const actual = MDToken.findFirstTokens(tokens, pattern);
 		const expected = {
 			tokens: [ tokens[2], tokens[3] ],
 			index: 2,
 		};
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_findFirstTokens_optionalWhitespace2() {
 			MDTokenType.META_OptionalWhitespace,
 			MDTokenType.URL,
 		];
-		const result = MDToken.findFirstTokens(tokens, pattern);
+		const actual = MDToken.findFirstTokens(tokens, pattern);
 		const expected = {
 			tokens: [ tokens[2], tokens[3], tokens[4] ],
 			index: 2,
 		};
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_findPairedTokens() {
 		const pattern = [
 			MDTokenType.Underscore,
 		];
-		const result = MDToken.findPairedTokens(tokens, pattern, pattern);
+		const actual = MDToken.findPairedTokens(tokens, pattern, pattern);
 		const expected = {
 			startTokens: [ tokens[2] ],
 			contentTokens: [ tokens[3] ],
 			endIndex: 4,
 			totalLength: 3,
 		}
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 }

jstest/UtilsTests.js

 class UtilsTests extends BaseTest {
 	test_stripIndent() {
-		this.assertEqual(MDUtils.stripIndent(''), '');
-		this.assertEqual(MDUtils.stripIndent('  '), '');
-		this.assertEqual(MDUtils.stripIndent('foo'), 'foo');
-		this.assertEqual(MDUtils.stripIndent(' foo'), 'foo');
-		this.assertEqual(MDUtils.stripIndent('  foo'), 'foo');
-		this.assertEqual(MDUtils.stripIndent('   foo'), 'foo');
-		this.assertEqual(MDUtils.stripIndent('    foo'), 'foo');
-		this.assertEqual(MDUtils.stripIndent('     foo'), ' foo');
-		this.assertEqual(MDUtils.stripIndent('\tfoo'), 'foo');
-		this.assertEqual(MDUtils.stripIndent('\t\tfoo'), '\tfoo');
-		this.assertEqual(MDUtils.stripIndent('\t\tfoo', 2), 'foo');
-		this.assertEqual(MDUtils.stripIndent('      foo', 2), 'foo');
+		this.assertEqual('', MDUtils.stripIndent(''));
+		this.assertEqual('', MDUtils.stripIndent('  '));
+		this.assertEqual('foo', MDUtils.stripIndent('foo'));
+		this.assertEqual('foo', MDUtils.stripIndent(' foo'));
+		this.assertEqual('foo', MDUtils.stripIndent('  foo'));
+		this.assertEqual('foo', MDUtils.stripIndent('   foo'));
+		this.assertEqual('foo', MDUtils.stripIndent('    foo'));
+		this.assertEqual(' foo', MDUtils.stripIndent('     foo'));
+		this.assertEqual('foo', MDUtils.stripIndent('\tfoo'));
+		this.assertEqual("\tfoo", MDUtils.stripIndent('\t\tfoo'));
+		this.assertEqual('foo', MDUtils.stripIndent('\t\tfoo', 2));
+		this.assertEqual('foo', MDUtils.stripIndent('      foo', 2));
 	}
 
 	test_countIndents() {
-		this.assertEqual(MDUtils.countIndents(''), 0);
-		this.assertEqual(MDUtils.countIndents('  '), 1);
-		this.assertEqual(MDUtils.countIndents('    '), 1);
-		this.assertEqual(MDUtils.countIndents('foo'), 0);
-		this.assertEqual(MDUtils.countIndents('foo'), 0);
-		this.assertEqual(MDUtils.countIndents(' foo'), 1);
-		this.assertEqual(MDUtils.countIndents('  foo'), 1);
-		this.assertEqual(MDUtils.countIndents('   foo'), 1);
-		this.assertEqual(MDUtils.countIndents('    foo'), 1);
-		this.assertEqual(MDUtils.countIndents('     foo'), 2);
-		this.assertEqual(MDUtils.countIndents('\tfoo'), 1);
-		this.assertEqual(MDUtils.countIndents('\t\tfoo'), 2);
+		this.assertEqual(0, MDUtils.countIndents(''));
+		this.assertEqual(1, MDUtils.countIndents('  '));
+		this.assertEqual(1, MDUtils.countIndents('    '));
+		this.assertEqual(0, MDUtils.countIndents('foo'));
+		this.assertEqual(0, MDUtils.countIndents('foo'));
+		this.assertEqual(1, MDUtils.countIndents(' foo'));
+		this.assertEqual(1, MDUtils.countIndents('  foo'));
+		this.assertEqual(1, MDUtils.countIndents('   foo'));
+		this.assertEqual(1, MDUtils.countIndents('    foo'));
+		this.assertEqual(2, MDUtils.countIndents('     foo'));
+		this.assertEqual(1, MDUtils.countIndents('\tfoo'));
+		this.assertEqual(2, MDUtils.countIndents('\t\tfoo'));
 
-		this.assertEqual(MDUtils.countIndents('', true), 0);
-		this.assertEqual(MDUtils.countIndents('  ', true), 0);
-		this.assertEqual(MDUtils.countIndents('    ', true), 1);
-		this.assertEqual(MDUtils.countIndents('foo', true), 0);
-		this.assertEqual(MDUtils.countIndents(' foo', true), 0);
-		this.assertEqual(MDUtils.countIndents('  foo', true), 0);
-		this.assertEqual(MDUtils.countIndents('   foo', true), 0);
-		this.assertEqual(MDUtils.countIndents('    foo', true), 1);
-		this.assertEqual(MDUtils.countIndents('     foo', true), 1);
-		this.assertEqual(MDUtils.countIndents('\tfoo', true), 1);
-		this.assertEqual(MDUtils.countIndents('\t\tfoo', true), 2);
+		this.assertEqual(0, MDUtils.countIndents('', true));
+		this.assertEqual(0, MDUtils.countIndents('  ', true));
+		this.assertEqual(1, MDUtils.countIndents('    ', true));
+		this.assertEqual(0, MDUtils.countIndents('foo', true));
+		this.assertEqual(0, MDUtils.countIndents(' foo', true));
+		this.assertEqual(0, MDUtils.countIndents('  foo', true));
+		this.assertEqual(0, MDUtils.countIndents('   foo', true));
+		this.assertEqual(1, MDUtils.countIndents('    foo', true));
+		this.assertEqual(1, MDUtils.countIndents('     foo', true));
+		this.assertEqual(1, MDUtils.countIndents('\tfoo', true));
+		this.assertEqual(2, MDUtils.countIndents('\t\tfoo', true));
 	}
 
 	test_tokenizeLabel() {
 		// Escapes are preserved
-		this.assertEqual(MDToken.tokenizeLabel('[foo] bar'), [ '[foo]', 'foo' ]);
-		this.assertEqual(MDToken.tokenizeLabel('[foo\\[] bar'), [ '[foo\\[]', 'foo\\[' ]);
-		this.assertEqual(MDToken.tokenizeLabel('[foo\\]] bar'), [ '[foo\\]]', 'foo\\]' ]);
-		this.assertEqual(MDToken.tokenizeLabel('[foo[]] bar'), [ '[foo[]]', 'foo[]' ]);
-		this.assertEqual(MDToken.tokenizeLabel('[foo\\(] bar'), [ '[foo\\(]', 'foo\\(' ]);
-		this.assertEqual(MDToken.tokenizeLabel('[foo\\)] bar'), [ '[foo\\)]', 'foo\\)' ]);
-		this.assertEqual(MDToken.tokenizeLabel('[foo()] bar'), [ '[foo()]', 'foo()' ]);
+		this.assertEqual([ '[foo]', 'foo' ], MDToken.tokenizeLabel('[foo] bar'));
+		this.assertEqual([ '[foo\\[]', 'foo\\[' ], MDToken.tokenizeLabel('[foo\\[] bar'));
+		this.assertEqual([ '[foo\\]]', 'foo\\]' ], MDToken.tokenizeLabel('[foo\\]] bar'));
+		this.assertEqual([ '[foo[]]', 'foo[]' ], MDToken.tokenizeLabel('[foo[]] bar'));
+		this.assertEqual([ '[foo\\(]', 'foo\\(' ], MDToken.tokenizeLabel('[foo\\(] bar'));
+		this.assertEqual([ '[foo\\)]', 'foo\\)' ], MDToken.tokenizeLabel('[foo\\)] bar'));
+		this.assertEqual([ '[foo()]', 'foo()' ], MDToken.tokenizeLabel('[foo()] bar'));
 
-		this.assertEqual(MDToken.tokenizeLabel('foo bar'), null);
-		this.assertEqual(MDToken.tokenizeLabel('[foo\\] bar'), null);
-		this.assertEqual(MDToken.tokenizeLabel('[foo bar'), null);
-		this.assertEqual(MDToken.tokenizeLabel('[foo[] bar'), null);
+		this.assertEqual(null, MDToken.tokenizeLabel('foo bar'));
+		this.assertEqual(null, MDToken.tokenizeLabel('[foo\\] bar'));
+		this.assertEqual(null, MDToken.tokenizeLabel('[foo bar'));
+		this.assertEqual(null, MDToken.tokenizeLabel('[foo[] bar'));
 	}
 
 	test_tokenizeURL() {
-		this.assertEqual(MDToken.tokenizeURL('(page.html) foo'), [ '(page.html)', 'page.html', null ]);
-		this.assertEqual(MDToken.tokenizeURL('(page.html "link title") foo'), [ '(page.html "link title")', 'page.html', 'link title' ]);
-		this.assertEqual(MDToken.tokenizeURL('(https://example.com/path/page.html?query=foo&bar=baz#fragment) foo'), [ '(https://example.com/path/page.html?query=foo&bar=baz#fragment)', 'https://example.com/path/page.html?query=foo&bar=baz#fragment', null ]);
+		this.assertEqual([ '(page.html)', 'page.html', null ], MDToken.tokenizeURL('(page.html) foo'));
+		this.assertEqual([ '(page.html "link title")', 'page.html', 'link title' ], MDToken.tokenizeURL('(page.html "link title") foo'));
+		this.assertEqual([ '(https://example.com/path/page.html?query=foo&bar=baz#fragment)', 'https://example.com/path/page.html?query=foo&bar=baz#fragment', null ], MDToken.tokenizeURL('(https://example.com/path/page.html?query=foo&bar=baz#fragment) foo'));
 
-		this.assertEqual(MDToken.tokenizeURL('page.html foo'), null);
-		this.assertEqual(MDToken.tokenizeURL('(page.html foo'), null);
-		this.assertEqual(MDToken.tokenizeURL('page.html) foo'), null);
-		this.assertEqual(MDToken.tokenizeURL('(page.html "title) foo'), null);
-		this.assertEqual(MDToken.tokenizeURL('(page .html) foo'), null);
-		this.assertEqual(MDToken.tokenizeURL('(user@example.com) foo'), null);
-		this.assertEqual(MDToken.tokenizeURL('(user@example.com "title") foo'), null);
+		this.assertEqual(null, MDToken.tokenizeURL('page.html foo'));
+		this.assertEqual(null, MDToken.tokenizeURL('(page.html foo'));
+		this.assertEqual(null, MDToken.tokenizeURL('page.html) foo'));
+		this.assertEqual(null, MDToken.tokenizeURL('(page.html "title) foo'));
+		this.assertEqual(null, MDToken.tokenizeURL('(page .html) foo'));
+		this.assertEqual(null, MDToken.tokenizeURL('(user@example.com) foo'));
+		this.assertEqual(null, MDToken.tokenizeURL('(user@example.com "title") foo'));
 	}
 
 	test_tokenizeEmail() {
-		this.assertEqual(MDToken.tokenizeEmail('(user@example.com)'), [ '(user@example.com)', 'user@example.com', null ]);
-		this.assertEqual(MDToken.tokenizeEmail('(user@example.com "link title")'), [ '(user@example.com "link title")', 'user@example.com', 'link title' ]);
+		this.assertEqual([ '(user@example.com)', 'user@example.com', null ], MDToken.tokenizeEmail('(user@example.com)'));
+		this.assertEqual([ '(user@example.com "link title")', 'user@example.com', 'link title' ], MDToken.tokenizeEmail('(user@example.com "link title")'));
 
-		this.assertEqual(MDToken.tokenizeEmail('(https://example.com) foo'), null);
-		this.assertEqual(MDToken.tokenizeEmail('(https://example.com "link title") foo'), null);
-		this.assertEqual(MDToken.tokenizeEmail('(user@example.com "link title) foo'), null);
-		this.assertEqual(MDToken.tokenizeEmail('(user@example.com foo'), null);
-		this.assertEqual(MDToken.tokenizeEmail('user@example.com) foo'), null);
+		this.assertEqual(null, MDToken.tokenizeEmail('(https://example.com) foo'));
+		this.assertEqual(null, MDToken.tokenizeEmail('(https://example.com "link title") foo'));
+		this.assertEqual(null, MDToken.tokenizeEmail('(user@example.com "link title) foo'));
+		this.assertEqual(null, MDToken.tokenizeEmail('(user@example.com foo'));
+		this.assertEqual(null, MDToken.tokenizeEmail('user@example.com) foo'));
 	}
 }

jstest/basetest.js

 		if (test) this.fail(failMessage || `expected false, got ${test}`);
 	}
 
-	assertEqual(a, b, failMessage=null) {
-		if (BaseTest.#equal(a, b, this.numberDifferenceRatio)) return;
-		const aVal = (typeof a == 'string') ? `"${a}"` : `${a}`;
-		const bVal = (typeof b == 'string') ? `"${b}"` : `${b}`;
-		if (aVal.length > 20 || bVal.length > 20) {
-			this.fail(failMessage || `equality failed:\n${aVal}\n!=\n${bVal}`);
+	assertEqual(expected, actual, failMessage=null) {
+		if (BaseTest.#equal(expected, actual, this.numberDifferenceRatio)) return;
+		const expectedStr = (typeof expected == 'string') ? `"${expected}"` : `${expected}`;
+		const actualStr = (typeof actual == 'string') ? `"${actual}"` : `${actual}`;
+		if (expectedStr.length > 20 || actualStr.length > 20) {
+			this.fail(failMessage || `equality failed:\nexpected:\n${expectedStr}\n!=\nactual:\n${actualStr}`);
 		} else {
-			this.fail(failMessage || `equality failed: ${aVal} != ${bVal}`);
+			this.fail(failMessage || `equality failed: expected ${expectedStr} != actual ${actualStr}`);
 		}
 	}
 

jstest/spreadsheet/CellAddressRangeTests.js

 			visited.push(address.name);
 			if (sanity-- < 0) break;
 		}
-		const result = visited.join(',');
+		const actual = visited.join(',');
 		const expected = 'A1,A2,A3,A4,B1,B2,B3,B4,C1,C2,C3,C4';
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_iterator_column() {
 			visited.push(address.name);
 			if (sanity-- < 0) break;
 		}
-		const result = visited.join(',');
+		const actual = visited.join(',');
 		const expected = 'B1,B2,B3,B4,C1,C2,C3,C4';
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_iterator_beyondBounds() {
 			visited.push(address.name);
 			if (sanity-- < 0) break;
 		}
-		const result = visited.join(',');
+		const actual = visited.join(',');
 		const expected = 'A2,A3,A4,B2,B3,B4,C2,C3,C4';
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_iterator_outOfBounds() {
 			visited.push(address.name);
 			if (sanity-- < 0) break;
 		}
-		const result = visited.join(',');
+		const actual = visited.join(',');
 		const expected = '';
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 }

jstest/spreadsheet/CellValueTests.js

 	test_fromCellString_blank() {
 		var value;
 		value = CellValue.fromCellString('');
-		this.assertEqual(value.type, CellValue.TYPE_BLANK);
-		this.assertEqual(value.formattedValue, '');
-		this.assertEqual(value.value, null);
+		this.assertEqual(CellValue.TYPE_BLANK, value.type);
+		this.assertEqual('', value.formattedValue);
+		this.assertEqual(null, value.value);
 		value = CellValue.fromCellString(' ');
-		this.assertEqual(value.type, CellValue.TYPE_BLANK);
-		this.assertEqual(value.formattedValue, '');
-		this.assertEqual(value.value, null);
+		this.assertEqual(CellValue.TYPE_BLANK, value.type);
+		this.assertEqual('', value.formattedValue);
+		this.assertEqual(null, value.value);
 	}
 
 	test_fromCellString_number() {
 		var value;
 		value = CellValue.fromCellString('123');
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '123');
-		this.assertEqual(value.value, 123);
-		this.assertEqual(value.decimals, 0);
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('123', value.formattedValue);
+		this.assertEqual(123, value.value);
+		this.assertEqual(0, value.decimals);
 		value = CellValue.fromCellString('-0');
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '-0');
-		this.assertEqual(value.value, 0);
-		this.assertEqual(value.decimals, 0);
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('-0', value.formattedValue);
+		this.assertEqual(0, value.value);
+		this.assertEqual(0, value.decimals);
 		value = CellValue.fromCellString('1,234');
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '1,234');
-		this.assertEqual(value.value, 1234);
-		this.assertEqual(value.decimals, 0);
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('1,234', value.formattedValue);
+		this.assertEqual(1234, value.value);
+		this.assertEqual(0, value.decimals);
 		value = CellValue.fromCellString('-1,234,567.89');
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '-1,234,567.89');
-		this.assertEqual(value.value, -1234567.89);
-		this.assertEqual(value.decimals, 2);
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('-1,234,567.89', value.formattedValue);
+		this.assertEqual(-1234567.89, value.value);
+		this.assertEqual(2, value.decimals);
 	}
 
 	test_fromCellString_percent() {
 		var value;
 		value = CellValue.fromCellString('123%');
-		this.assertEqual(value.type, CellValue.TYPE_PERCENT);
-		this.assertEqual(value.formattedValue, '123%');
-		this.assertEqual(value.value, 1.23, 0.0001);
-		this.assertEqual(value.decimals, 0);
+		this.assertEqual(CellValue.TYPE_PERCENT, value.type);
+		this.assertEqual('123%', value.formattedValue);
+		this.assertEqual(1.23, value.value);
+		this.assertEqual(0, value.decimals);
 		value = CellValue.fromCellString('-12.3%');
-		this.assertEqual(value.type, CellValue.TYPE_PERCENT);
-		this.assertEqual(value.formattedValue, '-12.3%');
-		this.assertEqual(value.value, -0.123, 0.0001);
-		this.assertEqual(value.decimals, 1);
+		this.assertEqual(CellValue.TYPE_PERCENT, value.type);
+		this.assertEqual('-12.3%', value.formattedValue);
+		this.assertEqual(-0.123, value.value);
+		this.assertEqual(1, value.decimals);
 	}
 
 	test_fromCellString_currency() {
 		var value;
 		value = CellValue.fromCellString('$123');
-		this.assertEqual(value.type, CellValue.TYPE_CURRENCY);
-		this.assertEqual(value.formattedValue, '$123');
-		this.assertEqual(value.value, 123);
-		this.assertEqual(value.decimals, 0);
+		this.assertEqual(CellValue.TYPE_CURRENCY, value.type);
+		this.assertEqual('$123', value.formattedValue);
+		this.assertEqual(123, value.value);
+		this.assertEqual(0, value.decimals);
 		value = CellValue.fromCellString('-$12.34');
-		this.assertEqual(value.type, CellValue.TYPE_CURRENCY);
-		this.assertEqual(value.formattedValue, '-$12.34');
-		this.assertEqual(value.value, -12.34, 0.0001);
-		this.assertEqual(value.decimals, 2);
+		this.assertEqual(CellValue.TYPE_CURRENCY, value.type);
+		this.assertEqual('-$12.34', value.formattedValue);
+		this.assertEqual(value.value, -12.34);
+		this.assertEqual(2, value.decimals);
 	}
 
 	test_fromCellString_boolean() {
 		var value;
 		value = CellValue.fromCellString('true');
-		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
-		this.assertEqual(value.formattedValue, 'TRUE');
-		this.assertEqual(value.value, true);
+		this.assertEqual(CellValue.TYPE_BOOLEAN, value.type);
+		this.assertEqual('TRUE', value.formattedValue);
+		this.assertEqual(true, value.value);
 		value = CellValue.fromCellString('false');
-		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
-		this.assertEqual(value.formattedValue, 'FALSE');
-		this.assertEqual(value.value, false);
+		this.assertEqual(CellValue.TYPE_BOOLEAN, value.type);
+		this.assertEqual('FALSE', value.formattedValue);
+		this.assertEqual(false, value.value);
 	}
 
 	test_fromCellString_string() {
 		var value;
 		value = CellValue.fromCellString('some text');
-		this.assertEqual(value.type, CellValue.TYPE_STRING);
-		this.assertEqual(value.formattedValue, 'some text');
-		this.assertEqual(value.value, 'some text');
+		this.assertEqual(CellValue.TYPE_STRING, value.type);
+		this.assertEqual('some text', value.formattedValue);
+		this.assertEqual('some text', value.value);
 		value = CellValue.fromCellString("'0123");
-		this.assertEqual(value.type, CellValue.TYPE_STRING);
-		this.assertEqual(value.formattedValue, '0123');
-		this.assertEqual(value.value, '0123');
+		this.assertEqual(CellValue.TYPE_STRING, value.type);
+		this.assertEqual('0123', value.formattedValue);
+		this.assertEqual('0123', value.value);
 		value = CellValue.fromCellString("'=123");
-		this.assertEqual(value.type, CellValue.TYPE_STRING);
-		this.assertEqual(value.formattedValue, '=123');
-		this.assertEqual(value.value, '=123');
+		this.assertEqual(CellValue.TYPE_STRING, value.type);
+		this.assertEqual('=123', value.formattedValue);
+		this.assertEqual('=123', value.value);
 	}
 
 	test_fromCellString_formula() {
 		var value;
 		value = CellValue.fromCellString('=A*B');
-		this.assertEqual(value.type, CellValue.TYPE_FORMULA);
-		this.assertEqual(value.formattedValue, '=A*B');
-		this.assertEqual(value.value, '=A*B');
+		this.assertEqual(CellValue.TYPE_FORMULA, value.type);
+		this.assertEqual('=A*B', value.formattedValue);
+		this.assertEqual('=A*B', value.value);
 		value = CellValue.fromCellString('=MAX(A, 3)');
-		this.assertEqual(value.type, CellValue.TYPE_FORMULA);
-		this.assertEqual(value.formattedValue, '=MAX(A, 3)');
-		this.assertEqual(value.value, '=MAX(A, 3)');
+		this.assertEqual(CellValue.TYPE_FORMULA, value.type);
+		this.assertEqual('=MAX(A, 3)', value.formattedValue);
+		this.assertEqual('=MAX(A, 3)', value.value);
 	}
 
 	test_fromValue_null() {
 		var value;
 		value = CellValue.fromValue(null);
-		this.assertEqual(value.type, CellValue.TYPE_BLANK);
+		this.assertEqual(CellValue.TYPE_BLANK, value.type);
 	}
 
 	test_fromValue_number() {
 		var value;
 		value = CellValue.fromValue(123);
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '123');
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('123', value.formattedValue);
 		value = CellValue.fromValue(3.141592);
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '3.141592');
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('3.141592', value.formattedValue);
 		value = CellValue.fromValue(123456789);
-		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
-		this.assertEqual(value.formattedValue, '123,456,789');
+		this.assertEqual(CellValue.TYPE_NUMBER, value.type);
+		this.assertEqual('123,456,789', value.formattedValue);
 	}
 
 	test_fromValue_boolean() {
 		var value;
 		value = CellValue.fromValue(true);
-		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
-		this.assertEqual(value.formattedValue, 'TRUE');
+		this.assertEqual(CellValue.TYPE_BOOLEAN, value.type);
+		this.assertEqual('TRUE', value.formattedValue);
 		value = CellValue.fromValue(false);
-		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
-		this.assertEqual(value.formattedValue, 'FALSE');
+		this.assertEqual(CellValue.TYPE_BOOLEAN, value.type);
+		this.assertEqual('FALSE', value.formattedValue);
 	}
 
 	test_fromValue_string() {
 		var value;
 		value = CellValue.fromValue('foo');
-		this.assertEqual(value.type, CellValue.TYPE_STRING);
-		this.assertEqual(value.formattedValue, 'foo');
+		this.assertEqual(CellValue.TYPE_STRING, value.type);
+		this.assertEqual('foo', value.formattedValue);
 		value = CellValue.fromValue('123');
-		this.assertEqual(value.type, CellValue.TYPE_STRING);
-		this.assertEqual(value.formattedValue, '123');
+		this.assertEqual(CellValue.TYPE_STRING, value.type);
+		this.assertEqual('123', value.formattedValue);
 	}
 
 	test_fromValue_formula() {
 		var value;
 		value = CellValue.fromValue('=A*B');
-		this.assertEqual(value.type, CellValue.TYPE_FORMULA);
-		this.assertEqual(value.formattedValue, '=A*B');
+		this.assertEqual(CellValue.TYPE_FORMULA, value.type);
+		this.assertEqual('=A*B', value.formattedValue);
 	}
 
 	test_operation_add() {
-		var a, b, result, expected;
+		var a, b, expected, actual;
 		a = CellValue.fromValue(3);
 		b = CellValue.fromValue(4);
-		result = a.add(b)
+		actual = a.add(b)
 		expected = new CellValue('7', 7, CellValue.TYPE_NUMBER, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('100%');
 		b = CellValue.fromCellString('50%');
-		result = a.add(b);
+		actual = a.add(b);
 		expected = new CellValue('150%', 1.5, CellValue.TYPE_PERCENT, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('$123');
 		b = CellValue.fromCellString('$321');
-		result = a.add(b);
+		actual = a.add(b);
 		expected = new CellValue('$444.00', 444, CellValue.TYPE_CURRENCY, 2);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_operation_subtract() {
-		var a, b, result, expected;
+		var a, b, expected, actual;
 		a = CellValue.fromValue(9);
 		b = CellValue.fromValue(4);
-		result = a.subtract(b)
+		actual = a.subtract(b)
 		expected = new CellValue('5', 5, CellValue.TYPE_NUMBER, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('100%');
 		b = CellValue.fromCellString('50%');
-		result = a.subtract(b);
+		actual = a.subtract(b);
 		expected = new CellValue('50%', 0.5, CellValue.TYPE_PERCENT, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('$321');
 		b = CellValue.fromCellString('$123');
-		result = a.subtract(b);
+		actual = a.subtract(b);
 		expected = new CellValue('$198.00', 198, CellValue.TYPE_CURRENCY, 2);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_operation_multiply() {
-		var a, b, result, expected;
+		var a, b, expected, actual;
 		a = CellValue.fromValue(3);
 		b = CellValue.fromValue(4);
-		result = a.multiply(b)
+		actual = a.multiply(b)
 		expected = new CellValue('12', 12, CellValue.TYPE_NUMBER, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('150%');
 		b = CellValue.fromCellString('50%');
-		result = a.multiply(b);
+		actual = a.multiply(b);
 		expected = new CellValue('75%', 0.75, CellValue.TYPE_PERCENT, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('$321');
 		b = CellValue.fromCellString('50%');
-		result = a.multiply(b);
+		actual = a.multiply(b);
 		expected = new CellValue('$160.50', 160.50, CellValue.TYPE_CURRENCY, 2);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_operation_divide() {
-		var a, b, result, expected;
+		var a, b, expected, actual;
 		a = CellValue.fromValue(12);
 		b = CellValue.fromValue(4);
-		result = a.divide(b)
+		actual = a.divide(b)
 		expected = new CellValue('3', 3, CellValue.TYPE_NUMBER, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('150%');
 		b = CellValue.fromCellString('50%');
-		result = a.divide(b);
+		actual = a.divide(b);
 		expected = new CellValue('300%', 3.0, CellValue.TYPE_PERCENT, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('$321');
 		b = CellValue.fromCellString('200%');
-		result = a.divide(b);
+		actual = a.divide(b);
 		expected = new CellValue('$160.50', 160.50, CellValue.TYPE_CURRENCY, 2);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_operation_modulo() {
-		var a, b, result, expected;
+		var a, b, expected, actual;
 		a = CellValue.fromValue(7);
 		b = CellValue.fromValue(4);
-		result = a.modulo(b)
+		actual = a.modulo(b)
 		expected = new CellValue('3', 3, CellValue.TYPE_NUMBER, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('175%');
 		b = CellValue.fromCellString('50%');
-		result = a.modulo(b);
+		actual = a.modulo(b);
 		expected = new CellValue('25%', 0.25, CellValue.TYPE_PERCENT, 0);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 
 		a = CellValue.fromCellString('$327');
 		b = CellValue.fromCellString('$20');
-		result = a.modulo(b);
+		actual = a.modulo(b);
 		expected = new CellValue('$7.00', 7.00, CellValue.TYPE_CURRENCY, 2);
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 
 	test_operation_unaryNot() {
-		this.assertEqual(CellValue.fromValue(true).not(), CellValue.fromValue(false));
-		this.assertEqual(CellValue.fromValue(false).not(), CellValue.fromValue(true));
+		this.assertEqual(CellValue.fromValue(false), CellValue.fromValue(true).not());
+		this.assertEqual(CellValue.fromValue(true), CellValue.fromValue(false).not());
 	}
 
 	test_operation_comparators() {
 		const t = CellValue.fromValue(true);
 		const f = CellValue.fromValue(false);
 
-		this.assertEqual(a.lt(b), t);
-		this.assertEqual(a.lte(b), t);
-		this.assertEqual(a.gt(b), f);
-		this.assertEqual(a.gte(b), f);
-		this.assertEqual(a.eq(b), f);
-		this.assertEqual(a.neq(b), t);
-
-		this.assertEqual(b.lt(a), f);
-		this.assertEqual(b.lte(a), f);
-		this.assertEqual(b.gt(a), t);
-		this.assertEqual(b.gte(a), t);
-		this.assertEqual(b.eq(a), f);
-		this.assertEqual(b.neq(a), t);
-
-		this.assertEqual(a.lt(a), f);
-		this.assertEqual(a.lte(a), t);
-		this.assertEqual(a.gt(a), f);
-		this.assertEqual(a.gte(a), t);
-		this.assertEqual(a.eq(a), t);
-		this.assertEqual(a.neq(a), f);
+		this.assertEqual(t, a.lt(b));
+		this.assertEqual(t, a.lte(b));
+		this.assertEqual(f, a.gt(b));
+		this.assertEqual(f, a.gte(b));
+		this.assertEqual(f, a.eq(b));
+		this.assertEqual(t, a.neq(b));
+
+		this.assertEqual(f, b.lt(a));
+		this.assertEqual(f, b.lte(a));
+		this.assertEqual(t, b.gt(a));
+		this.assertEqual(t, b.gte(a));
+		this.assertEqual(f, b.eq(a));
+		this.assertEqual(t, b.neq(a));
+
+		this.assertEqual(f, a.lt(a));
+		this.assertEqual(t, a.lte(a));
+		this.assertEqual(f, a.gt(a));
+		this.assertEqual(t, a.gte(a));
+		this.assertEqual(t, a.eq(a));
+		this.assertEqual(f, a.neq(a));
 	}
 
 	test_operation_concatenate() {
 		const a = CellValue.fromValue('abc');
 		const b = CellValue.fromValue('xyz');
-		const result = a.concatenate(b);
+		const actual = a.concatenate(b);
 		const expected = CellValue.fromValue('abcxyz');
-		this.assertEqual(result, expected);
+		this.assertEqual(expected, actual);
 	}
 }

jstest/spreadsheet/ExpressionSetTests.js

 		const expressionSet = new CellExpressionSet(grid);
 		expressionSet.calculateCells();
 		const expected = CellValue.fromValue(21);
-		this.assertEqual(grid.cells[0][0].outputValue, expected);
+		const actual = grid.cells[0][0].outputValue;
+		this.assertEqual(expected, actual);
 	}
 
 	test_reference() {
 		const expressionSet = new CellExpressionSet(grid);
 		expressionSet.calculateCells();
 		const expected = CellValue.fromValue(369);
-		this.assertEqual(grid.cells[2][0].outputValue, expected);
+		const actual = grid.cells[2][0].outputValue;
+		this.assertEqual(expected, actual);
 	}
 
 	test_infixPriority() {
 		const expressionSet = new CellExpressionSet(grid);
 		expressionSet.calculateCells();
 		const expected = CellValue.fromValue(15);
-		this.assertEqual(grid.cells[0][0].outputValue, expected);
+		const actual = grid.cells[0][0].outputValue;
+		this.assertEqual(expected, actual);
 	}
 
 	test_filledFormula() {
 		grid.cells[1][2].originalValue = CellValue.fromValue(9);
 		const expressionSet = new CellExpressionSet(grid);
 		expressionSet.calculateCells();
-		this.assertEqual(grid.cells[2][0].outputValue, CellValue.fromValue(20));
-		this.assertEqual(grid.cells[2][1].outputValue, CellValue.fromValue(42));
-		this.assertEqual(grid.cells[2][2].outputValue, CellValue.fromValue(72));
+		this.assertEqual(CellValue.fromValue(20), grid.cells[2][0].outputValue);
+		this.assertEqual(CellValue.fromValue(42), grid.cells[2][1].outputValue);
+		this.assertEqual(CellValue.fromValue(72), grid.cells[2][2].outputValue);
 	}
 
 	test_dependencies() {
 		grid.cells[1][3].originalValue = CellValue.fromCellString('=A4');
 		const expressionSet = new CellExpressionSet(grid);
 		expressionSet.calculateCells();
-		this.assertEqual(grid.cells[1][0].outputValue, CellValue.fromValue(10));
-		this.assertEqual(grid.cells[1][1].outputValue, CellValue.fromValue(9));
-		this.assertEqual(grid.cells[1][2].outputValue, CellValue.fromValue(7));
-		this.assertEqual(grid.cells[1][3].outputValue, CellValue.fromValue(4));
+		this.assertEqual(CellValue.fromValue(10), grid.cells[1][0].outputValue);
+		this.assertEqual(CellValue.fromValue(9), grid.cells[1][1].outputValue);
+		this.assertEqual(CellValue.fromValue(7), grid.cells[1][2].outputValue);
+		this.assertEqual(CellValue.fromValue(4), grid.cells[1][3].outputValue);
 	}
 
-	_test_simple_formula(formula, expected) {
+	_test_simple_formula(expected, formula) {
 		const grid = new SpreadsheetGrid(1, 1);
 		grid.cells[0][0].originalValue = CellValue.fromCellString(formula);
 		const expressionSet = new CellExpressionSet(grid);
 		expressionSet.calculateCells();
-		const result = grid.cells[0][0].outputValue;
+		const actual = grid.cells[0][0].outputValue;
 		const exp = (expected instanceof CellValue) ? expected : CellValue.fromValue(expected);
-		this.assertEqual(result.type, exp.type);
-		this.assertEqual(result.decimals, exp.decimals);
-		this.assertEqual(result.formattedValue, exp.formattedValue);
-		this.assertEqual(result.value, exp.value);
+		this.assertEqual(exp.type, actual.type);
+		this.assertEqual(exp.decimals, actual.decimals);
+		this.assertEqual(exp.formattedValue, actual.formattedValue);
+		this.assertEqual(exp.value, actual.value);
 	}
 
 	test_func_abs() {
-		this._test_simple_formula('=ABS(-3)', 3);
-		this._test_simple_formula('=ABS(4)', 4);
+		this._test_simple_formula(3, '=ABS(-3)');
+		this._test_simple_formula(4, '=ABS(4)');
 	}
 
 	test_func_and() {
-		this._test_simple_formula('=AND(FALSE, FALSE)', false);
-		this._test_simple_formula('=AND(FALSE, TRUE)', false);
-		this._test_simple_formula('=AND(TRUE, FALSE)', false);
-		this._test_simple_formula('=AND(TRUE, TRUE)', true);
-		this._test_simple_formula('=AND(TRUE, TRUE, TRUE, TRUE)', true);
-		this._test_simple_formula('=AND(TRUE, TRUE, TRUE, FALSE)', false);
+		this._test_simple_formula(false, '=AND(FALSE, FALSE)');
+		this._test_simple_formula(false, '=AND(FALSE, TRUE)');
+		this._test_simple_formula(false, '=AND(TRUE, FALSE)');
+		this._test_simple_formula(true, '=AND(TRUE, TRUE)');
+		this._test_simple_formula(true, '=AND(TRUE, TRUE, TRUE, TRUE)');
+		this._test_simple_formula(false, '=AND(TRUE, TRUE, TRUE, FALSE)');
 	}
 
 	test_func_average() {
-		this._test_simple_formula('=AVERAGE(4, 6, 2, 4)', 4);
-		this._test_simple_formula('=AVERAGE(4, 6, 2, "foo", 4)', 4);
+		this._test_simple_formula(4, '=AVERAGE(4, 6, 2, 4)');
+		this._test_simple_formula(4, '=AVERAGE(4, 6, 2, "foo", 4)');
 	}
 
 	test_func_ceiling() {
-		this._test_simple_formula('=CEILING(3.1)', 4);
-		this._test_simple_formula('=CEILING(3)', 3);
-		this._test_simple_formula('=CEILING(-3.1)', -3);
+		this._test_simple_formula(4, '=CEILING(3.1)');
+		this._test_simple_formula(3, '=CEILING(3)');
+		this._test_simple_formula(-3, '=CEILING(-3.1)');
 	}
 
 	test_func_exp() {
-		this._test_simple_formula('=EXP(1)', 2.718281828459045);
+		this._test_simple_formula(2.718281828459045, '=EXP(1)');
 	}
 
 	test_func_floor() {
-		this._test_simple_formula('=FLOOR(3.1)', 3);
-		this._test_simple_formula('=FLOOR(3)', 3);
-		this._test_simple_formula('=FLOOR(-3.1)', -4);
+		this._test_simple_formula(3, '=FLOOR(3.1)');
+		this._test_simple_formula(3, '=FLOOR(3)');
+		this._test_simple_formula(-4, '=FLOOR(-3.1)');
 	}
 
 	test_func_if() {
-		this._test_simple_formula('=IF(FALSE, 4, 6)', 6);
-		this._test_simple_formula('=IF(TRUE, 4, 6)', 4);
+		this._test_simple_formula(6, '=IF(FALSE, 4, 6)');
+		this._test_simple_formula(4, '=IF(TRUE, 4, 6)');
 	}
 
 	test_func_ifs() {
-		this._test_simple_formula('=IFS(TRUE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)', 1);
-		this._test_simple_formula('=IFS(FALSE, 1, TRUE, 2, FALSE, 3, FALSE, 4, 5)', 2);
-		this._test_simple_formula('=IFS(FALSE, 1, FALSE, 2, TRUE, 3, FALSE, 4, 5)', 3);
-		this._test_simple_formula('=IFS(FALSE, 1, FALSE, 2, FALSE, 3, TRUE, 4, 5)', 4);
-		this._test_simple_formula('=IFS(FALSE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)', 5);
+		this._test_simple_formula(1, '=IFS(TRUE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)');
+		this._test_simple_formula(2, '=IFS(FALSE, 1, TRUE, 2, FALSE, 3, FALSE, 4, 5)');
+		this._test_simple_formula(3, '=IFS(FALSE, 1, FALSE, 2, TRUE, 3, FALSE, 4, 5)');
+		this._test_simple_formula(4, '=IFS(FALSE, 1, FALSE, 2, FALSE, 3, TRUE, 4, 5)');
+		this._test_simple_formula(5, '=IFS(FALSE, 1, FALSE, 2, FALSE, 3, FALSE, 4, 5)');
 	}
 
 	test_func_ln() {
-		this._test_simple_formula('=LN(2.718281828459045)', 1);
+		this._test_simple_formula(1, '=LN(2.718281828459045)');
 	}
 
 	test_func_log() {
-		this._test_simple_formula('=LOG(1000, 10)', 3);
-		this._test_simple_formula('=LOG(64, 2)', 6);
+		this._test_simple_formula(3, '=LOG(1000, 10)');
+		this._test_simple_formula(6, '=LOG(64, 2)');
 	}
 
 	test_func_lower() {
-		this._test_simple_formula('=LOWER("MiXeD")', 'mixed');
+		this._test_simple_formula('mixed', '=LOWER("MiXeD")');
 	}
 
 	test_func_max() {
-		this._test_simple_formula('=MAX(4, 8, 5, 2)', 8);
+		this._test_simple_formula(8, '=MAX(4, 8, 5, 2)');
 	}
 
 	test_func_min() {
-		this._test_simple_formula('=MIN(4, 8, 5, 2)', 2);
+		this._test_simple_formula(2, '=MIN(4, 8, 5, 2)');
 	}
 
 	test_func_mod() {
-		this._test_simple_formula('=MOD(37, 4)', 1);
+		this._test_simple_formula(1, '=MOD(37, 4)');
 	}
 
 	test_func_not() {
-		this._test_simple_formula('=NOT(TRUE)', false);
-		this._test_simple_formula('=NOT(FALSE)', true);
+		this._test_simple_formula(false, '=NOT(TRUE)');
+		this._test_simple_formula(true, '=NOT(FALSE)');
 	}
 
 	test_func_or() {
-		this._test_simple_formula('=OR(FALSE, FALSE)', false);
-		this._test_simple_formula('=OR(FALSE, TRUE)', true);
-		this._test_simple_formula('=OR(TRUE, FALSE)', true);
-		this._test_simple_formula('=OR(TRUE, TRUE)', true);
-		this._test_simple_formula('=OR(FALSE, FALSE, FALSE, TRUE)', true);
+		this._test_simple_formula(false, '=OR(FALSE, FALSE)');
+		this._test_simple_formula(true, '=OR(FALSE, TRUE)');
+		this._test_simple_formula(true, '=OR(TRUE, FALSE)');
+		this._test_simple_formula(true, '=OR(TRUE, TRUE)');
+		this._test_simple_formula(true, '=OR(FALSE, FALSE, FALSE, TRUE)');
 	}
 
 	test_func_power() {
-		this._test_simple_formula('=POWER(2, 3)', 8);
+		this._test_simple_formula(8, '=POWER(2, 3)');
 	}
 
 	test_func_round() {
-		this._test_simple_formula('=ROUND(3.1)', 3);
-		this._test_simple_formula('=ROUND(3.5)', 4);
-		this._test_simple_formula('=ROUND(4)', 4);
-		this._test_simple_formula('=ROUND(-3.1)', -3);
-		this._test_simple_formula('=ROUND(-3.5)', -3);
-		this._test_simple_formula('=ROUND(-3.9)', -4);
-		this._test_simple_formula('=ROUND(3.1415926535, 1)', 3.1);
-		this._test_simple_formula('=ROUND(3.1415926535, 2)', 3.14);
-		this._test_simple_formula('=ROUND(31.415926535, -1)', 30);
+		this._test_simple_formula(3, '=ROUND(3.1)');
+		this._test_simple_formula(4, '=ROUND(3.5)');
+		this._test_simple_formula(4, '=ROUND(4)');
+		this._test_simple_formula(-3, '=ROUND(-3.1)');
+		this._test_simple_formula(-3, '=ROUND(-3.5)');
+		this._test_simple_formula(-4, '=ROUND(-3.9)');
+		this._test_simple_formula(3.1, '=ROUND(3.1415926535, 1)');
+		this._test_simple_formula(3.14, '=ROUND(3.1415926535, 2)');
+		this._test_simple_formula(30, '=ROUND(31.415926535, -1)');
 	}
 
 	test_func_sqrt() {
-		this._test_simple_formula('=SQRT(16)', 4);
+		this._test_simple_formula(4, '=SQRT(16)');
 	}
 
 	test_func_substitute() {
-		this._test_simple_formula('=SUBSTITUTE("cat sat on the mat", "at", "ot")', 'cot sot on the mot');
-		this._test_simple_formula('=SUBSTITUTE("cAt saT on the mat", "at", "ot")', 'cot sot on the mot');
-		this._test_simple_formula('=SUBSTITUTE("c.*t s.*t on the m.*t", ".*t", "ot")', 'cot sot on the mot');
+		this._test_simple_formula('cot sot on the mot', '=SUBSTITUTE("cat sat on the mat", "at", "ot")');
+		this._test_simple_formula('cot sot on the mot', '=SUBSTITUTE("cAt saT on the mat", "at", "ot")');
+		this._test_simple_formula('cot sot on the mot', '=SUBSTITUTE("c.*t s.*t on the m.*t", ".*t", "ot")');
 	}
 
 	test_func_sum() {
-		this._test_simple_formula('=SUM(1, 2, 3, 4, 5)', 15);
+		this._test_simple_formula(15, '=SUM(1, 2, 3, 4, 5)');
 	}
 
 	test_func_upper() {
-		this._test_simple_formula('=UPPER("mIxEd")', 'MIXED');
+		this._test_simple_formula('MIXED', '=UPPER("mIxEd")');
 	}
 
 	test_func_xor() {
-		this._test_simple_formula('=XOR(FALSE, FALSE)', false);
-		this._test_simple_formula('=XOR(FALSE, TRUE)', true);
-		this._test_simple_formula('=XOR(TRUE, FALSE)', true);
-		this._test_simple_formula('=XOR(TRUE, TRUE)', false);
-		this._test_simple_formula('=XOR(FALSE, FALSE, TRUE)', true);
-		this._test_simple_formula('=XOR(TRUE, FALSE, TRUE)', false);
+		this._test_simple_formula(false, '=XOR(FALSE, FALSE)');
+		this._test_simple_formula(true, '=XOR(FALSE, TRUE)');
+		this._test_simple_formula(true, '=XOR(TRUE, FALSE)');
+		this._test_simple_formula(false, '=XOR(TRUE, TRUE)');
+		this._test_simple_formula(true, '=XOR(FALSE, FALSE, TRUE)');
+		this._test_simple_formula(false, '=XOR(TRUE, FALSE, TRUE)');
 	}
 
 	test_format() {
-		this._test_simple_formula('=2.718281828459045 ; number 3', new CellValue('2.718', 2.718281828459045, 'number', 3));
-		this._test_simple_formula('=2.718281828459045 ; percent 2', new CellValue('271.83%', 2.718281828459045, 'percent', 2));
-		this._test_simple_formula('=2.718281828459045 ; currency 2', new CellValue('$2.72', 2.718281828459045, 'currency', 2));
+		this._test_simple_formula(new CellValue('2.718', 2.718281828459045, 'number', 3), '=2.718281828459045 ; number 3');
+		this._test_simple_formula(new CellValue('271.83%', 2.718281828459045, 'percent', 2), '=2.718281828459045 ; percent 2');
+		this._test_simple_formula(new CellValue('$2.72', 2.718281828459045, 'currency', 2), '=2.718281828459045 ; currency 2');
 	}
 }

jstest/spreadsheet/SpreadsheetMarkdownIntegrationTests.js

 
 	test_integration() {
 		const markdown = '| A | B | C |\n| --- | --- | --- |\n| 3 | 4 | =A*B |';
-		const expected = '<table> <thead> ' +
-			'<tr> <th>A</th> <th>B</th> <th>C</th> </tr> ' +
-			'</thead> <tbody> <tr> ' +
-			'<td class="spreadsheet-type-number" data-numeric-value="3" data-string-value="3">3</td> ' +
-			'<td class="spreadsheet-type-number" data-numeric-value="4" data-string-value="4">4</td> ' +
-			'<td class="calculated spreadsheet-type-number" data-numeric-value="12" data-string-value="12">12</td> ' +
-			'</tr> </tbody> </table>';
-		const result = this.md(markdown);
-		this.assertEqual(result, expected);
+		const expected = '<table><thead>' +
+			'<tr><th>A</th><th>B</th><th>C</th></tr>' +
+			'</thead><tbody><tr>' +
+			'<td class="spreadsheet-type-number" data-numeric-value="3" data-string-value="3">3</td>' +
+			'<td class="spreadsheet-type-number" data-numeric-value="4" data-string-value="4">4</td>' +
+			'<td class="calculated spreadsheet-type-number" data-numeric-value="12" data-string-value="12">12</td>' +
+			'</tr></tbody></table>';
+		const actual = this.md(markdown);
+		this.assertEqual(expected, actual);
 	}
 
 	test_bailOut() {
 		// If no formulas found table isn't modified
 		const markdown = '| A | B | C |\n| --- | --- | --- |\n| 3 | 4 | A*B |';
-		const expected = '<table> <thead> ' +
-			'<tr> <th>A</th> <th>B</th> <th>C</th> </tr> ' +
-			'</thead> <tbody> <tr> ' +
-			'<td>3</td> ' +
-			'<td>4</td> ' +
-			'<td>A*B</td> ' +
-			'</tr> </tbody> </table>';
-		const result = this.md(markdown);
-		this.assertEqual(result, expected);
+		const expected = '<table><thead>' +
+			'<tr><th>A</th><th>B</th><th>C</th></tr>' +
+			'</thead><tbody><tr>' +
+			'<td>3</td>' +
+			'<td>4</td>' +
+			'<td>A*B</td>' +
+			'</tr></tbody></table>';
+		const actual = this.md(markdown);
+		this.assertEqual(expected, actual);
 	}
 
 	test_observedError1() {
 		// Saw "Uncaught Error: columnIndex must be number, got string" from this
 		const markdown = '| Unit Price | Qty | Subtotal |\n| ---: | ---: | ---: |\n| $1.23 | 2 | =A*B FILL |\n| $4.99 | 6 | |\n| Total | | =SUM(C:C) |';
-		const expected = '<table> <thead> <tr> ' +
-			'<th style="text-align: right;">Unit Price</th> ' +
-			'<th style="text-align: right;">Qty</th> ' +
-			'<th>Subtotal</th> ' +
-			'</tr> </thead> <tbody> <tr> ' +
-			'<td class="spreadsheet-type-currency" style="text-align: right;" data-numeric-value="1.23" data-string-value="1.23">$1.23</td> ' +
-			'<td class="spreadsheet-type-number" style="text-align: right;" data-numeric-value="2" data-string-value="2">2</td> ' +
-			'<td class="calculated spreadsheet-type-currency" data-numeric-value="2.46" data-string-value="2.46">$2.46</td> ' +
-			'</tr> <tr> ' +
-			'<td class="spreadsheet-type-currency" style="text-align: right;" data-numeric-value="4.99" data-string-value="4.99">$4.99</td> ' +
-			'<td class="spreadsheet-type-number" style="text-align: right;" data-numeric-value="6" data-string-value="6">6</td> ' +
-			'<td class="calculated spreadsheet-type-currency" data-numeric-value="29.94" data-string-value="29.94">$29.94</td> ' +
-			'</tr> <tr> ' +
-			'<td class="spreadsheet-type-string" style="text-align: right;" data-string-value="Total">Total</td> ' +
-			'<td class="spreadsheet-type-blank" style="text-align: right;" data-numeric-value="0" data-string-value=""></td> ' +
-			'<td class="calculated spreadsheet-type-currency" data-numeric-value="32.4" data-string-value="32.4">$32.40</td> ' +
-			'</tr> </tbody> </table>';
-		const result = this.md(markdown);
-		this.assertEqual(result, expected);
+		const expected = '<table><thead><tr>' +
+			'<th style="text-align: right;">Unit Price</th>' +
+			'<th style="text-align: right;">Qty</th>' +
+			'<th>Subtotal</th>' +
+			'</tr></thead><tbody><tr>' +
+			'<td class="spreadsheet-type-currency" style="text-align: right;" data-numeric-value="1.23" data-string-value="1.23">$1.23</td>' +
+			'<td class="spreadsheet-type-number" style="text-align: right;" data-numeric-value="2" data-string-value="2">2</td>' +
+			'<td class="calculated spreadsheet-type-currency" data-numeric-value="2.46" data-string-value="2.46">$2.46</td>' +
+			'</tr><tr>' +
+			'<td class="spreadsheet-type-currency" style="text-align: right;" data-numeric-value="4.99" data-string-value="4.99">$4.99</td>' +
+			'<td class="spreadsheet-type-number" style="text-align: right;" data-numeric-value="6" data-string-value="6">6</td>' +
+			'<td class="calculated spreadsheet-type-currency" data-numeric-value="29.94" data-string-value="29.94">$29.94</td>' +
+			'</tr><tr>' +
+			'<td class="spreadsheet-type-string" style="text-align: right;" data-string-value="Total">Total</td>' +
+			'<td class="spreadsheet-type-blank" style="text-align: right;" data-numeric-value="0" data-string-value=""></td>' +
+			'<td class="calculated spreadsheet-type-currency" data-numeric-value="32.4" data-string-value="32.4">$32.40</td>' +
+			'</tr></tbody></table>';
+		const actual = this.md(markdown);
+		this.assertEqual(expected, actual);
 	}
 }

php/markdown.php

 		return MDUtils::stripIndent($lines);
 	}
 
-	protected function readListItemContent(MDState $state, int $firstLineStartPos): MDBlockNode {
+	protected function readListItemContent(MDState $state, int $firstLineStartPos): MDNode|array {
 		$itemLines = $this->readItemLines($state, $firstLineStartPos);
 		$state->p += max(sizeof($itemLines), 1);
 
 		if (sizeof($itemLines) == 1) {
-			return new MDBlockNode($state->inlineMarkdownToNodes($itemLines[0]));
+			return $state->inlineMarkdownToNodes($itemLines[0]);
 		}
 
 		$hasBlankLines = sizeof(array_filter($itemLines, fn($line) => trim($line) == '')) > 0;
 		if ($hasBlankLines) {
 			$substate = $state->copy($itemLines);
-			$blocks = $substate->readBlocks();
-			return (sizeof($blocks) == 1) ? $blocks[0] : new MBlockDNode($blocks);
+			return $substate->readBlocks();
 		}
 
 		// Multiline content with no blank lines. Search for new block
 			$line = $itemLines[$p];
 			if (mb_eregi('^(?:\\*|\\-|\\+|\\d+\\.)\\s+', $line)) {
 				// Nested list found
-				$firstBlock = new MDBlockNode($state->inlineMarkdownToNodes(
-					implode("\n", array_slice($itemLines, 0, $p))));
+				$firstNodes = $state->inlineMarkdownToNodes(
+					implode("\n", array_slice($itemLines, 0, $p)));
 				$substate = $state->copy(array_slice($itemLines, $p));
 				$blocks = $substate->readBlocks();
-				return new MDBlockNode(array_merge([ $firstBlock ], $blocks));
+				return new MDBlockNode(array_merge($firstNodes, $blocks));
 			}
 		}
 
 		// Ok, give up and just do a standard block read
 		{
 			$substate = $state->copy($itemLines);
-			$blocks = $substate->readBlocks();
-			return (sizeof($blocks) == 1) ? $blocks[0] : new MDBlockNode($blocks);
+			return $substate->readBlocks();
 		}
 	}
 
 		$openFenceLine = $state->lines[$p++];
 		[$openFenceLine, $modifier] = MDTagModifier::fromLine($openFenceLine, $state);
 		if (!mb_eregi('```\\s*([a-z0-9]*)\\s*$', $openFenceLine, $groups)) return null;
-		$language = mb_strlen($groups[1]) > 0 ? $groups[1] : null;
+		$language = $groups[1] !== false && mb_strlen($groups[1]) > 0 ? $groups[1] : null;
 		$codeLines = [];
 		while ($state->hasLines(1, $p)) {
 			$line = $state->lines[$p++];
 	 * and child content will be rendered between the tags.
 	 */
 	protected function simplePairedTagHTML(MDState $state, string $tagName): string {
-		$openTagSuffix = $this->children[0] instanceof MDBlockNode ? "\n" : "";
-		$closeTagPrefix = $this->children[sizeof($this->children) - 1] instanceof MDBlockNode ? "\n" : '';
+		$openTagSuffix = ($this->children[0] ?? null) instanceof MDBlockNode ? "\n" : "";
+		$closeTagPrefix = ($this->children[sizeof($this->children) - 1] ?? null) instanceof MDBlockNode ? "\n" : '';
 		$closeTagSuffix = $this instanceof MDBlockNode ? "\n" : '';
 		$attr = $this->htmlAttributes();
 		$childHTML = $this->childHTML($state);
 	 * @return string HTML string
 	 */
 	public static function arrayToHTML(array $nodes, MDState $state): string {
-		return implode('', array_map(function($node) use ($state) {
-			return $node->toHTML($state) . ($node instanceof MDBlockNode ? "\n" : '');
-		}, $nodes));
+		return implode('', array_map(fn($node) => $node->toHTML($state) . ($node instanceof MDBlockNode ? "\n" : ''), $nodes));
 	}
 
 	/**

phptest/BlockTests.php

+<?php
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../php/markdown.php';
+
+final class BlockTests extends TestCase {
+	private ?Markdown $parser = null;
+
+	protected function setUp(): void {
+		parent::setUp();
+		$this->parser = Markdown::completeParser();
+	}
+
+	private function md(string $markdown): string {
+		return $this->normalizeWhitespace($this->parser->toHTML($markdown));
+	}
+
+	private function normalizeWhitespace(string $str): string {
+		$str = mb_eregi_replace('\\s+', ' ', $str);
+		$str = mb_eregi_replace('>\\s+<', '><', $str);
+		return trim($str);
+	}
+
+	public function test_paragraphs() {
+		$markdown = "Lorem ipsum\n\nDolor sit amet";
+		$expected = "<p>Lorem ipsum</p><p>Dolor sit amet</p>";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_paragraph_lineGrouping() {
+		$markdown = "Lorem ipsum\ndolor sit amet";
+		$expected = "Lorem ipsum dolor sit amet";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_header_underlineH1() {
+		$markdown = "Header 1\n===\n\nLorem ipsum";
+		$expected = "<h1>Header 1</h1><p>Lorem ipsum</p>";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_header_underlineH2() {
+		$markdown = "Header 2\n---\n\nLorem ipsum";
+		$expected = "<h2>Header 2</h2><p>Lorem ipsum</p>";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_header_hash() {
+		$markdown = "# Header 1\n## Header 2\n### Header 3\n#### Header 4\n##### Header 5\n###### Header 6\n";
+		$expected = '<h1>Header 1</h1><h2>Header 2</h2><h3>Header 3</h3><h4>Header 4</h4><h5>Header 5</h5><h6>Header 6</h6>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_header_hash_trailing() {
+		$markdown = "# Header 1 #\n## Header 2 ##\n### Header 3 ######";
+		$expected = '<h1>Header 1</h1><h2>Header 2</h2><h3>Header 3</h3>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_unorderedList() {
+		$markdown = "* Lorem\n* Ipsum\n* Dolor";
+		$expected = '<ul><li>Lorem</li><li>Ipsum</li><li>Dolor</li></ul>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_unorderedList_nested() {
+		$markdown = "* Lorem\n + Ipsum\n* Dolor";
+		$expected = '<ul><li> Lorem<ul><li>Ipsum</li></ul></li><li>Dolor</li></ul>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_unorderedList_hitch() {
+		// This incomplete bulleted list locked up the browser at one
+		// point, not forever but a REALLY long time
+		$markdown = "Testing\n\n* ";
+		$expected = '<p>Testing</p><ul><li></li></ul>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_orderedList() {
+		$markdown = "1. Lorem\n1. Ipsum\n5. Dolor";
+		$expected = '<ol><li>Lorem</li><li>Ipsum</li><li>Dolor</li></ol>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_orderedList_numbering() {
+		$markdown = "4. Lorem\n1. Ipsum\n9. Dolor";
+		$expected = '<ol start="4"><li>Lorem</li><li>Ipsum</li><li>Dolor</li></ol>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_orderedList_nested1() {
+		$markdown = "1. Lorem\n 1. Ipsum\n1. Dolor";
+		$expected = '<ol><li> Lorem<ol><li>Ipsum</li></ol></li><li>Dolor</li></ol>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_orderedList_nested2() {
+		$markdown = "1. Lorem\n 1. Ipsum\n      1. Dolor\n 1. Sit\n1. Amet";
+		$expected = '<ol><li> Lorem<ol><li> Ipsum<ol><li>Dolor</li></ol></li><li>Sit</li></ol></li><li>Amet</li></ol>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_blockquote() {
+		$markdown = '> Lorem ipsum dolor';
+		$expected = '<blockquote> Lorem ipsum dolor </blockquote>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_blockquote_paragraphs() {
+		$markdown = "> Lorem ipsum dolor\n>\n>Sit amet";
+		$expected = '<blockquote><p>Lorem ipsum dolor</p><p>Sit amet</p></blockquote>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_blockquote_list() {
+		$markdown = "> 1. Lorem\n> 2. Ipsum";
+		$expected = '<blockquote><ol><li>Lorem</li><li>Ipsum</li></ol></blockquote>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_codeBlock_indented() {
+		$markdown = "Code\n\n    function foo() {\n        return 'bar';\n    }\n\nend";
+		$expected = "<p>Code</p>\n\n<pre><code>function foo() {\n    return 'bar';\n}</code></pre>\n\n<p>end</p>";
+		$actual = trim($this->parser->toHTML($markdown)); // don't normalize whitespace
+		$this->assertSame(mb_ereg_replace(' ', '⎵', $expected), mb_ereg_replace(' ', '⎵', $actual));
+	}
+
+	public function test_codeBlock_fenced() {
+		$markdown = "Code\n\n```\nfunction foo() {\n    return 'bar';\n}\n```\n\nend";
+		$expected = "<p>Code</p>\n\n<pre><code>function foo() {\n    return 'bar';\n}</code></pre>\n\n<p>end</p>";
+		$actual = trim($this->parser->toHTML($markdown)); // don't normalize whitespace
+		$this->assertSame(mb_ereg_replace(' ', '⎵', $expected), mb_ereg_replace(' ', '⎵', $actual));
+	}
+
+	public function test_codeBlock_fenced_language() {
+		$markdown = "Code\n\n```javascript\nfunction foo() {\n    return 'bar';\n}\n```\n\nend";
+		$expected = "<p>Code</p>\n\n<pre><code class=\"language-javascript\">function foo() {\n    return 'bar';\n}</code></pre>\n\n<p>end</p>";
+		$actual = trim($this->parser->toHTML($markdown)); // don't normalize whitespace
+		$this->assertSame(mb_ereg_replace(' ', '⎵', $expected), mb_ereg_replace(' ', '⎵', $actual));
+	}
+
+	public function test_horizontalRule() {
+		$markdown = "Before\n\n---\n\n- - -\n\n***\n\n* * * * * * *\n\nafter";
+		$expected = "<p>Before</p><hr><hr><hr><hr><p>after</p>";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_table_unfenced() {
+		$markdown = "Column A | Column B | Column C\n--- | --- | ---\n1 | 2 | 3\n4 | 5 | 6";
+		$expected = "<table><thead><tr><th>Column A</th><th>Column B</th><th>Column C</th></tr></thead><tbody><tr><td>1</td><td>2</td><td>3</td></tr><tr><td>4</td><td>5</td><td>6</td></tr></tbody></table>";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_table_fenced() {
+		$markdown = "| Column A | Column B | Column C |\n| --- | --- | --- |\n| 1 | 2 | 3\n4 | 5 | 6 |";
+		$expected = "<table><thead><tr><th>Column A</th><th>Column B</th><th>Column C</th></tr></thead><tbody><tr><td>1</td><td>2</td><td>3</td></tr><tr><td>4</td><td>5</td><td>6</td></tr></tbody></table>";
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_table_alignment() {
+		$markdown = "Column A | Column B | Column C\n" .
+			":--- | :---: | ---:\n" .
+			"1 | 2 | 3\n" .
+			"4 | 5 | 6";
+		$expected = '<table>' .
+			'<thead>' .
+			'<tr>' .
+			'<th style="text-align: left;">Column A</th>' .
+			'<th style="text-align: center;">Column B</th>' .
+			'<th style="text-align: right;">Column C</th>' .
+			'</tr>' .
+			'</thead>' .
+			'<tbody>' .
+			'<tr>' .
+			'<td style="text-align: left;">1</td>' .
+			'<td style="text-align: center;">2</td>' .
+			'<td style="text-align: right;">3</td>' .
+			'</tr>' .
+			'<tr>' .
+			'<td style="text-align: left;">4</td>' .
+			'<td style="text-align: center;">5</td>' .
+			'<td style="text-align: right;">6</td>' .
+			'</tr>' .
+			'</tbody>' .
+			'</table>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_table_holes() {
+		$markdown = "Column A||Column C\n" .
+			"---|---|---\n" .
+			"|1|2||\n" .
+			"|4||6|\n" .
+			"||8|9|";
+		$expected = '<table>' .
+			'<thead>' .
+			'<tr>' .
+			'<th>Column A</th>' .
+			'<th></th>' .
+			'<th>Column C</th>' .
+			'</tr>' .
+			'</thead>' .
+			'<tbody>' .
+			'<tr>' .
+			'<td>1</td>' .
+			'<td>2</td>' .
+			'<td></td>' .
+			'</tr>' .
+			'<tr>' .
+			'<td>4</td>' .
+			'<td></td>' .
+			'<td>6</td>' .
+			'</tr>' .
+			'<tr>' .
+			'<td></td>' .
+			'<td>8</td>' .
+			'<td>9</td>' .
+			'</tr>' .
+			'</tbody>' .
+			'</table>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_definitionList() {
+		$markdown = "term\n" .
+			": definition\n" .
+			"another" .
+			" term\n" .
+			": def 1\n" .
+			" broken on next line\n" .
+			": def 2";
+		$expected = '<dl>' .
+			'<dt>term</dt>' .
+			'<dd>definition</dd>' .
+			'<dt>another term</dt>' .
+			'<dd>def 1 broken on next line</dd>' .
+			'<dd>def 2</dd>' .
+			'</dl>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_footnotes() {
+		$markdown = "Lorem ipsum[^1] dolor[^abc] sit[^1] amet\n\n[^1]: A footnote\n[^abc]: Another footnote";
+		$expected = '<p>Lorem ipsum<sup class="footnote" id="footnoteref_1"><a href="#footnote_1">1</a></sup> ' .
+			'dolor<sup class="footnote" id="footnoteref_2"><a href="#footnote_2">2</a></sup> ' .
+			'sit<sup class="footnote" id="footnoteref_3"><a href="#footnote_1">1</a></sup> amet</p>' .
+			'<div class="footnotes">' .
+			'<ol>' .
+			'<li value="1" id="footnote_1">A footnote <a href="#footnoteref_1" class="footnote-backref">↩︎</a><a href="#footnoteref_3" class="footnote-backref">↩︎</a></li>' .
+			'<li value="2" id="footnote_2">Another footnote <a href="#footnoteref_2" class="footnote-backref">↩︎</a></li>' .
+			'</ol>' .
+			'</div>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+
+	public function test_abbreviations() {
+		$markdown = "Lorem ipsum HTML dolor HTML sit\n" .
+			"\n" .
+			"*[HTML]: Hypertext Markup Language";
+		$expected = '<p>Lorem ipsum <abbr title="Hypertext Markup Language">HTML</abbr> dolor <abbr title="Hypertext Markup Language">HTML</abbr> sit</p>';
+		$actual = $this->md($markdown);
+		$this->assertSame($expected, $actual);
+	}
+}

phptest/InlineTests.php

 require_once __DIR__ . '/../php/markdown.php';
 
 final class InlineTests extends TestCase {
-	/** @type {Markdown} */
 	private ?Markdown $parser = null;
 
 	protected function setUp(): void {

phptest/TokenTests.php

 		$pattern = [
 			MDTokenType::Underscore,
 		];
-		$result = MDToken::findFirstTokens($tokens, $pattern);
+		$actual = MDToken::findFirstTokens($tokens, $pattern);
 		$expected = new MDTokenMatch([ $tokens[2] ], 2);
-		$this->assertEquals($expected, $result);
+		$this->assertEquals($expected, $actual);
 	}
 
 	public function test_findFirstTokens_optionalWhitespace1() {
 			MDTokenType::META_OptionalWhitespace,
 			MDTokenType::URL,
 		];
-		$result = MDToken::findFirstTokens($tokens, $pattern);
+		$actual = MDToken::findFirstTokens($tokens, $pattern);
 		$expected = new MDTokenMatch([ $tokens[2], $tokens[3] ], 2);
-		$this->assertEquals($expected, $result);
+		$this->assertEquals($expected, $actual);
 	}
 
 	public function test_findFirstTokens_optionalWhitespace2() {
 			MDTokenType::META_OptionalWhitespace,
 			MDTokenType::URL,
 		];
-		$result = MDToken::findFirstTokens($tokens, $pattern);
+		$actual = MDToken::findFirstTokens($tokens, $pattern);
 		$expected = new MDTokenmatch([ $tokens[2], $tokens[3], $tokens[4] ], 2);
-		$this->assertEquals($expected, $result);
+		$this->assertEquals($expected, $actual);
 	}
 
 	public function test_findPairedTokens() {
 		$pattern = [
 			MDTokenType::Underscore,
 		];
-		$result = MDToken::findPairedTokens($tokens, $pattern, $pattern);
+		$actual = MDToken::findPairedTokens($tokens, $pattern, $pattern);
 		$expected = new MDPairedTokenMatch(
 			[ $tokens[2] ], // startTokens
 			[ $tokens[3] ], // contentTokens
 			4, // endIndex
 			3 // totalLength
 		);
-		$this->assertEquals($expected, $result);
+		$this->assertEquals($expected, $actual);
 	}
 }
 ?>

runphptests.sh

 #!/bin/sh
-php lib/phpunit.phar \
+php lib/phpunit.phar --display-warnings --display-notices \
 	phptest/UtilsTests.php \
 	phptest/TokenTests.php \
 	phptest/InlineTests.php \
-
+	phptest/BlockTests.php \

testjs.html

 			document.addEventListener('DOMContentLoaded', onLoad);
 
 			function normalizeWhitespace(str) {
-				return str.replace(/\s+/g, ' ').replace(/(?:^\s+|\s+$)/g, '');
+				return str.replace(/\s+/gs, ' ').replace(/>\s+</gs, '><').trim();
 			}
 		</script>
 	</head>