Writing first PHP unit tests. Breaking JS unit test classes into separate files

jstest/BlockTests.js

@@ -0,0 +1,278 @@
+class BlockTests extends BaseTest {
+	/** @type {Markdown} */
+	parser;
+	md(markdown) {
+		return normalizeWhitespace(this.parser.toHTML(markdown));
+	}
+
+	setUp() {
+		this.parser = Markdown.completeParser;
+	}
+
+	test_paragraphs() {
+		let markdown = "Lorem ipsum\n\nDolor sit amet";
+		let expected = "<p>Lorem ipsum</p> <p>Dolor sit amet</p>";
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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);
+	}
+
+	test_header_underlineH1() {
+		let markdown = "Header 1\n===\n\nLorem ipsum";
+		let expected = "<h1>Header 1</h1> <p>Lorem ipsum</p>";
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_header_underlineH2() {
+		let markdown = "Header 2\n---\n\nLorem ipsum";
+		let expected = "<h2>Header 2</h2> <p>Lorem ipsum</p>";
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_unorderedList() {
+		let markdown = "* Lorem\n* Ipsum\n* Dolor";
+		let expected = '<ul> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ul>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_unorderedList_hitch() {
+		// This incomplete bulleted list locked up the browser at one
+		// 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 actual = this.md(markdown);
+			this.assertEqual(actual, expected);
+		});
+	}
+
+	test_orderedList() {
+		let markdown = "1. Lorem\n1. Ipsum\n5. Dolor";
+		let expected = '<ol> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ol>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_blockquote() {
+		let markdown = '> Lorem ipsum dolor';
+		let expected = '<blockquote>Lorem ipsum dolor</blockquote>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_blockquote_list() {
+		let markdown = '> 1. Lorem\n> 2. Ipsum';
+		let expected = '<blockquote> <ol> <li>Lorem</li> <li>Ipsum</li> </ol> </blockquote>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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, '⎵'));
+	}
+
+	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, '⎵'));
+	}
+
+	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, '⎵'));
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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 actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_table_alignment() {
+		let markdown = 'Column A | Column B | Column C\n' +
+			':--- | :---: | ---:\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> ' +
+			'</table>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_table_holes() {
+		let markdown = 'Column A||Column C\n' +
+			'---|---|---\n' +
+			'|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> ' +
+			'</table>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_definitionList() {
+		let markdown = 'term\n' +
+			': definition\n' +
+			'another' +
+			' term\n' +
+			': 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> ' +
+			'</dl>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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> ' +
+			'<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>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_abbreviations() {
+		let markdown = 'Lorem ipsum HTML dolor HTML sit\n' +
+			'\n' +
+			'*[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);
+	}
+}

jstest/InlineTests.js

@@ -0,0 +1,237 @@
+class InlineTests extends BaseTest {
+	/** @type {Markdown} */
+	parser;
+	md(markdown) {
+		return normalizeWhitespace(this.parser.toHTML(markdown));
+	}
+
+	setUp() {
+		this.parser = Markdown.completeParser;
+	}
+
+	test_simpleText() {
+		let markdown = 'Lorem ipsum';
+		let expected = 'Lorem ipsum';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	test_strongEmphasis_tightNesting() {
+		let markdown = 'Lorem ***ipsum*** dolor';
+		let expected1 = 'Lorem <strong><em>ipsum</em></strong> dolor';
+		let expected2 = 'Lorem <em><strong>ipsum</strong></em> dolor';
+		let actual = this.md(markdown);
+		this.assertTrue(actual == expected1 || actual == expected2);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	test_inlineCode() {
+		let markdown = 'Lorem `ipsum` dolor';
+		let expected = 'Lorem <code>ipsum</code> dolor';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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);
+	}
+
+	test_strikethrough_double() {
+		let markdown = 'Lorem ~~ipsum~~ dolor';
+		let expected = 'Lorem <s>ipsum</s> dolor';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_subscript() {
+		let markdown = 'H~2~O';
+		let expected = 'H<sub>2</sub>O';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_superscript() {
+		let markdown = 'E=mc^2^';
+		let expected = 'E=mc<sup>2</sup>';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_highlight() {
+		let markdown = 'Lorem ==ipsum== dolor';
+		let expected = 'Lorem <mark>ipsum</mark> dolor';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	test_underline() {
+		let markdown = 'Lorem __ipsum__ dolor';
+		let expected = 'Lorem <u>ipsum</u> dolor';
+		let actual = this.md(markdown);
+		this.assertEqual(actual, expected);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	test_image_ref() {
+		let markdown = 'Lorem ![alt text][ref] dolor\n\n' +
+			'[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);
+	}
+
+	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);
+	}
+}

jstest/TokenTests.js

@@ -0,0 +1,99 @@
+class TokenTests extends BaseTest {
+	test_findFirstTokens() {
+		const tokens = [
+			new MDToken('Lorem', MDTokenType.Text),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('_', MDTokenType.Underscore),
+			new MDToken('ipsum', MDTokenType.Text),
+			new MDToken('_', MDTokenType.Underscore),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('dolor', MDTokenType.Text),
+			new MDToken('_', MDTokenType.Underscore),
+			new MDToken('sit', MDTokenType.Text),
+			new MDToken('_', MDTokenType.Underscore),
+		];
+		const pattern = [
+			MDTokenType.Underscore,
+		];
+		const result = MDToken.findFirstTokens(tokens, pattern);
+		const expected = {
+			tokens: [ tokens[2] ],
+			index: 2,
+		};
+		this.assertEqual(result, expected);
+	}
+
+	test_findFirstTokens_optionalWhitespace1() {
+		const tokens = [
+			new MDToken('Lorem', MDTokenType.Text),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('[ipsum]', MDTokenType.Label, 'ipsum'),
+			new MDToken('(link.html)', MDTokenType.URL, 'link.html'),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('dolor', MDTokenType.Text),
+		];
+		const pattern = [
+			MDTokenType.Label,
+			MDTokenType.META_OptionalWhitespace,
+			MDTokenType.URL,
+		];
+		const result = MDToken.findFirstTokens(tokens, pattern);
+		const expected = {
+			tokens: [ tokens[2], tokens[3] ],
+			index: 2,
+		};
+		this.assertEqual(result, expected);
+	}
+
+	test_findFirstTokens_optionalWhitespace2() {
+		const tokens = [
+			new MDToken('Lorem', MDTokenType.Text),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('[ipsum]', MDTokenType.Label, 'ipsum'),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('(link.html)', MDTokenType.URL, 'link.html'),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('dolor', MDTokenType.Text),
+		];
+		const pattern = [
+			MDTokenType.Label,
+			MDTokenType.META_OptionalWhitespace,
+			MDTokenType.URL,
+		];
+		const result = MDToken.findFirstTokens(tokens, pattern);
+		const expected = {
+			tokens: [ tokens[2], tokens[3], tokens[4] ],
+			index: 2,
+		};
+		this.assertEqual(result, expected);
+	}
+
+	test_findPairedTokens() {
+		const tokens = [
+			new MDToken('Lorem', MDTokenType.Text),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('_', MDTokenType.Underscore),
+			new MDToken('ipsum', MDTokenType.Text),
+			new MDToken('_', MDTokenType.Underscore),
+			new MDToken(' ', MDTokenType.Whitespace),
+			new MDToken('dolor', MDTokenType.Text),
+			new MDToken('_', MDTokenType.Underscore),
+			new MDToken('sit', MDTokenType.Text),
+			new MDToken('_', MDTokenType.Underscore),
+		];
+		const pattern = [
+			MDTokenType.Underscore,
+		];
+		const result = MDToken.findPairedTokens(tokens, pattern, pattern);
+		const expected = {
+			startTokens: [ tokens[2] ],
+			contentTokens: [ tokens[3] ],
+			endTokens: [ tokens[4] ],
+			startIndex: 2,
+			contentIndex: 3,
+			endIndex: 4,
+			totalLength: 3,
+		}
+		this.assertEqual(result, expected);
+	}
+}

jstest/UtilsTests.js

@@ -0,0 +1,84 @@
+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');
+	}
+
+	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(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);
+	}
+
+	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(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);
+	}
+
+	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(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);
+	}
+
+	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(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);
+	}
+}

jstest/basetest.js

@@ -0,0 +1,123 @@
+class BaseTest {
+	numberDifferenceRatio = 0.000_001;
+
+	setUp() {}
+
+	tearDown() {}
+
+	/** @var {TestCaseRunner|null} */
+	currentRunner = null;
+
+	fail(failMessage=null) {
+		throw new FailureError(failMessage || 'failed');
+	}
+
+	assertTrue(test, failMessage=null) {
+		if (!test) this.fail(failMessage || `expected true, got ${test}`);
+	}
+
+	assertFalse(test, failMessage=null) {
+		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}`);
+		} else {
+			this.fail(failMessage || `equality failed: ${aVal} != ${bVal}`);
+		}
+	}
+
+	expectError(e=true) {
+		if (this.currentRunner) this.currentRunner.expectedError = e;
+	}
+
+	/**
+	 * @param {number} maxTime maximum time in seconds
+	 * @param {function} timedCode code to run and time
+	 */
+	profile(maxTime, timedCode) {
+		const startTime = performance.now();
+		const result = timedCode();
+		const endTime = performance.now();
+		const seconds = (endTime - startTime) / 1000.0;
+		if (seconds > maxTime) {
+			this.fail(`Expected <= ${maxTime}s execution time, actual ${seconds}s.`);
+		}
+		return result;
+	}
+
+	/**
+	 * @param {Array} a
+	 * @param {Array} b
+	 * @returns {boolean}
+	 */
+	static #equalArrays(a, b) {
+		if (a === b) return true;
+		if (!(a instanceof Array) || !(b instanceof Array)) return false;
+		if (a == null || b == null) return false;
+		if (a.length != b.length) return false;
+		for (var i = 0; i < a.length; i++) {
+			if (!this.#equal(a[i], b[i])) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * @param {object} a
+	 * @param {object} b
+	 * @returns {boolean}
+	 */
+	static #equalObjects(a, b) {
+		if (a === b) return true;
+		if (!(a instanceof Object) || !(b instanceof Object)) return false;
+		if (a == null || b == null) return false;
+		if (a.equals !== undefined) {
+			return a.equals(b);
+		}
+		for (const key of Object.keys(a)) {
+			if (!this.#equal(a[key], b[key])) return false;
+		}
+		for (const key of Object.keys(b)) {
+			if (!this.#equal(a[key], b[key])) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * @param {number} a
+	 * @param {number} b
+	 * @returns {boolean}
+	 */
+	static #equalNumbers(a, b, differenceRatio=0.000001) {
+		if (a === b) return true;
+		const largestAllowableDelta = Math.max(Math.abs(a), Math.abs(b)) * differenceRatio;
+		const delta = Math.abs(a - b);
+		return delta <= largestAllowableDelta;
+	}
+
+	/**
+	 * Tests for equality on lots of different kinds of values including objects
+	 * and arrays. Will use `.equals` on objects that implement it.
+	 *
+	 * @param {any} a
+	 * @param {any} b
+	 * @param {number} numberDifferenceRatio
+	 * @returns {boolean}
+	 */
+	static #equal(a, b, numberDifferenceRatio=0.000_001) {
+		if (a instanceof Array && b instanceof Array) {
+			return this.#equalArrays(a, b);
+		}
+		if (a instanceof Object && b instanceof Object) {
+			return this.#equalObjects(a, b);
+		}
+		if (typeof a === 'number' && typeof b === 'number') {
+			return this.#equalNumbers(a, b, numberDifferenceRatio);
+		}
+		return a === b;
+	}
+}

jstest/spreadsheet/CellAddressRangeTests.js

@@ -0,0 +1,57 @@
+class CellAddressRangeTests extends BaseTest {
+	test_iterator() {
+		const grid = new SpreadsheetGrid(3, 4);
+		let range = new CellAddressRange(new CellAddress(0, 0), new CellAddress(2, 3));
+		var visited = [];
+		var sanity = 100;
+		for (const address of range.cellsIn(grid)) {
+			visited.push(address.name);
+			if (sanity-- < 0) break;
+		}
+		const result = visited.join(',');
+		const expected = 'A1,A2,A3,A4,B1,B2,B3,B4,C1,C2,C3,C4';
+		this.assertEqual(result, expected);
+	}
+
+	test_iterator_column() {
+		const grid = new SpreadsheetGrid(3, 4);
+		let range = new CellAddressRange(new CellAddress(1, -1), new CellAddress(2, -1));
+		var visited = [];
+		var sanity = 100;
+		for (const address of range.cellsIn(grid)) {
+			visited.push(address.name);
+			if (sanity-- < 0) break;
+		}
+		const result = visited.join(',');
+		const expected = 'B1,B2,B3,B4,C1,C2,C3,C4';
+		this.assertEqual(result, expected);
+	}
+
+	test_iterator_beyondBounds() {
+		const grid = new SpreadsheetGrid(3, 4);
+		let range = new CellAddressRange(new CellAddress(0, 1), new CellAddress(9, 9));
+		var visited = [];
+		var sanity = 100;
+		for (const address of range.cellsIn(grid)) {
+			visited.push(address.name);
+			if (sanity-- < 0) break;
+		}
+		const result = visited.join(',');
+		const expected = 'A2,A3,A4,B2,B3,B4,C2,C3,C4';
+		this.assertEqual(result, expected);
+	}
+
+	test_iterator_outOfBounds() {
+		const grid = new SpreadsheetGrid(3, 4);
+		let range = new CellAddressRange(new CellAddress(5, 0), new CellAddress(5, 9));
+		var visited = [];
+		var sanity = 100;
+		for (const address of range.cellsIn(grid)) {
+			visited.push(address.name);
+			if (sanity-- < 0) break;
+		}
+		const result = visited.join(',');
+		const expected = '';
+		this.assertEqual(result, expected);
+	}
+}

jstest/spreadsheet/CellValueTests.js

@@ -0,0 +1,297 @@
+class CellValueTests extends BaseTest {
+	test_fromCellString_blank() {
+		var value;
+		value = CellValue.fromCellString('');
+		this.assertEqual(value.type, CellValue.TYPE_BLANK);
+		this.assertEqual(value.formattedValue, '');
+		this.assertEqual(value.value, null);
+		value = CellValue.fromCellString(' ');
+		this.assertEqual(value.type, CellValue.TYPE_BLANK);
+		this.assertEqual(value.formattedValue, '');
+		this.assertEqual(value.value, null);
+	}
+
+	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);
+		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);
+		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);
+		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);
+	}
+
+	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);
+		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);
+	}
+
+	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);
+		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);
+	}
+
+	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);
+		value = CellValue.fromCellString('false');
+		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+		this.assertEqual(value.formattedValue, 'FALSE');
+		this.assertEqual(value.value, false);
+	}
+
+	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');
+		value = CellValue.fromCellString("'0123");
+		this.assertEqual(value.type, CellValue.TYPE_STRING);
+		this.assertEqual(value.formattedValue, '0123');
+		this.assertEqual(value.value, '0123');
+		value = CellValue.fromCellString("'=123");
+		this.assertEqual(value.type, CellValue.TYPE_STRING);
+		this.assertEqual(value.formattedValue, '=123');
+		this.assertEqual(value.value, '=123');
+	}
+
+	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');
+		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)');
+	}
+
+	test_fromValue_null() {
+		var value;
+		value = CellValue.fromValue(null);
+		this.assertEqual(value.type, CellValue.TYPE_BLANK);
+	}
+
+	test_fromValue_number() {
+		var value;
+		value = CellValue.fromValue(123);
+		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+		this.assertEqual(value.formattedValue, '123');
+		value = CellValue.fromValue(3.141592);
+		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+		this.assertEqual(value.formattedValue, '3.141592');
+		value = CellValue.fromValue(123456789);
+		this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+		this.assertEqual(value.formattedValue, '123,456,789');
+	}
+
+	test_fromValue_boolean() {
+		var value;
+		value = CellValue.fromValue(true);
+		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+		this.assertEqual(value.formattedValue, 'TRUE');
+		value = CellValue.fromValue(false);
+		this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+		this.assertEqual(value.formattedValue, 'FALSE');
+	}
+
+	test_fromValue_string() {
+		var value;
+		value = CellValue.fromValue('foo');
+		this.assertEqual(value.type, CellValue.TYPE_STRING);
+		this.assertEqual(value.formattedValue, 'foo');
+		value = CellValue.fromValue('123');
+		this.assertEqual(value.type, CellValue.TYPE_STRING);
+		this.assertEqual(value.formattedValue, '123');
+	}
+
+	test_fromValue_formula() {
+		var value;
+		value = CellValue.fromValue('=A*B');
+		this.assertEqual(value.type, CellValue.TYPE_FORMULA);
+		this.assertEqual(value.formattedValue, '=A*B');
+	}
+
+	test_operation_add() {
+		var a, b, result, expected;
+		a = CellValue.fromValue(3);
+		b = CellValue.fromValue(4);
+		result = a.add(b)
+		expected = new CellValue('7', 7, CellValue.TYPE_NUMBER, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('100%');
+		b = CellValue.fromCellString('50%');
+		result = a.add(b);
+		expected = new CellValue('150%', 1.5, CellValue.TYPE_PERCENT, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('$123');
+		b = CellValue.fromCellString('$321');
+		result = a.add(b);
+		expected = new CellValue('$444.00', 444, CellValue.TYPE_CURRENCY, 2);
+		this.assertEqual(result, expected);
+	}
+
+	test_operation_subtract() {
+		var a, b, result, expected;
+		a = CellValue.fromValue(9);
+		b = CellValue.fromValue(4);
+		result = a.subtract(b)
+		expected = new CellValue('5', 5, CellValue.TYPE_NUMBER, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('100%');
+		b = CellValue.fromCellString('50%');
+		result = a.subtract(b);
+		expected = new CellValue('50%', 0.5, CellValue.TYPE_PERCENT, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('$321');
+		b = CellValue.fromCellString('$123');
+		result = a.subtract(b);
+		expected = new CellValue('$198.00', 198, CellValue.TYPE_CURRENCY, 2);
+		this.assertEqual(result, expected);
+	}
+
+	test_operation_multiply() {
+		var a, b, result, expected;
+		a = CellValue.fromValue(3);
+		b = CellValue.fromValue(4);
+		result = a.multiply(b)
+		expected = new CellValue('12', 12, CellValue.TYPE_NUMBER, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('150%');
+		b = CellValue.fromCellString('50%');
+		result = a.multiply(b);
+		expected = new CellValue('75%', 0.75, CellValue.TYPE_PERCENT, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('$321');
+		b = CellValue.fromCellString('50%');
+		result = a.multiply(b);
+		expected = new CellValue('$160.50', 160.50, CellValue.TYPE_CURRENCY, 2);
+		this.assertEqual(result, expected);
+	}
+
+	test_operation_divide() {
+		var a, b, result, expected;
+		a = CellValue.fromValue(12);
+		b = CellValue.fromValue(4);
+		result = a.divide(b)
+		expected = new CellValue('3', 3, CellValue.TYPE_NUMBER, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('150%');
+		b = CellValue.fromCellString('50%');
+		result = a.divide(b);
+		expected = new CellValue('300%', 3.0, CellValue.TYPE_PERCENT, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('$321');
+		b = CellValue.fromCellString('200%');
+		result = a.divide(b);
+		expected = new CellValue('$160.50', 160.50, CellValue.TYPE_CURRENCY, 2);
+		this.assertEqual(result, expected);
+	}
+
+	test_operation_modulo() {
+		var a, b, result, expected;
+		a = CellValue.fromValue(7);
+		b = CellValue.fromValue(4);
+		result = a.modulo(b)
+		expected = new CellValue('3', 3, CellValue.TYPE_NUMBER, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('175%');
+		b = CellValue.fromCellString('50%');
+		result = a.modulo(b);
+		expected = new CellValue('25%', 0.25, CellValue.TYPE_PERCENT, 0);
+		this.assertEqual(result, expected);
+
+		a = CellValue.fromCellString('$327');
+		b = CellValue.fromCellString('$20');
+		result = a.modulo(b);
+		expected = new CellValue('$7.00', 7.00, CellValue.TYPE_CURRENCY, 2);
+		this.assertEqual(result, expected);
+	}
+
+	test_operation_unaryNot() {
+		this.assertEqual(CellValue.fromValue(true).not(), CellValue.fromValue(false));
+		this.assertEqual(CellValue.fromValue(false).not(), CellValue.fromValue(true));
+	}
+
+	test_operation_comparators() {
+		const a = CellValue.fromValue(3);
+		const b = CellValue.fromValue(4);
+		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);
+	}
+
+	test_operation_concatenate() {
+		const a = CellValue.fromValue('abc');
+		const b = CellValue.fromValue('xyz');
+		const result = a.concatenate(b);
+		const expected = CellValue.fromValue('abcxyz');
+		this.assertEqual(result, expected);
+	}
+}

jstest/spreadsheet/ExpressionSetTests.js

@@ -0,0 +1,212 @@
+class ExpressionSetTests extends BaseTest {
+	test_simpleMath() {
+		const grid = new SpreadsheetGrid(1, 1);
+		grid.cells[0][0].originalValue = CellValue.fromCellString('=7*3');
+		const expressionSet = new CellExpressionSet(grid);
+		expressionSet.calculateCells();
+		const expected = CellValue.fromValue(21);
+		this.assertEqual(grid.cells[0][0].outputValue, expected);
+	}
+
+	test_reference() {
+		const grid = new SpreadsheetGrid(3, 1);
+		grid.cells[0][0].originalValue = CellValue.fromValue(123);
+		grid.cells[1][0].originalValue = CellValue.fromValue(3);
+		grid.cells[2][0].originalValue = CellValue.fromCellString('=A1*B1');
+		const expressionSet = new CellExpressionSet(grid);
+		expressionSet.calculateCells();
+		const expected = CellValue.fromValue(369);
+		this.assertEqual(grid.cells[2][0].outputValue, expected);
+	}
+
+	test_infixPriority() {
+		const grid = new SpreadsheetGrid(1, 1);
+		grid.cells[0][0].originalValue = CellValue.fromCellString('=4*9/3+7-4');
+		const expressionSet = new CellExpressionSet(grid);
+		expressionSet.calculateCells();
+		const expected = CellValue.fromValue(15);
+		this.assertEqual(grid.cells[0][0].outputValue, expected);
+	}
+
+	test_filledFormula() {
+		const grid = new SpreadsheetGrid(3, 3);
+		grid.cells[0][0].originalValue = CellValue.fromValue(4);
+		grid.cells[1][0].originalValue = CellValue.fromValue(5);
+		grid.cells[2][0].originalValue = CellValue.fromCellString('=A1*B1 FILL');
+		grid.cells[0][1].originalValue = CellValue.fromValue(6);
+		grid.cells[1][1].originalValue = CellValue.fromValue(7);
+		grid.cells[0][2].originalValue = CellValue.fromValue(8);
+		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));
+	}
+
+	test_dependencies() {
+		const grid = new SpreadsheetGrid(2, 4);
+		grid.cells[0][0].originalValue = CellValue.fromValue(1);
+		grid.cells[1][0].originalValue = CellValue.fromCellString('=A1+B2');
+		grid.cells[0][1].originalValue = CellValue.fromValue(2);
+		grid.cells[1][1].originalValue = CellValue.fromCellString('=A2+B3');
+		grid.cells[0][2].originalValue = CellValue.fromValue(3);
+		grid.cells[1][2].originalValue = CellValue.fromCellString('=A3+B4');
+		grid.cells[0][3].originalValue = CellValue.fromValue(4);
+		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));
+	}
+
+	_test_simple_formula(formula, expected) {
+		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 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);
+	}
+
+	test_func_abs() {
+		this._test_simple_formula('=ABS(-3)', 3);
+		this._test_simple_formula('=ABS(4)', 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);
+	}
+
+	test_func_average() {
+		this._test_simple_formula('=AVERAGE(4, 6, 2, 4)', 4);
+		this._test_simple_formula('=AVERAGE(4, 6, 2, "foo", 4)', 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);
+	}
+
+	test_func_exp() {
+		this._test_simple_formula('=EXP(1)', 2.718281828459045);
+	}
+
+	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);
+	}
+
+	test_func_if() {
+		this._test_simple_formula('=IF(FALSE, 4, 6)', 6);
+		this._test_simple_formula('=IF(TRUE, 4, 6)', 4);
+	}
+
+	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);
+	}
+
+	test_func_ln() {
+		this._test_simple_formula('=LN(2.718281828459045)', 1);
+	}
+
+	test_func_log() {
+		this._test_simple_formula('=LOG(1000, 10)', 3);
+		this._test_simple_formula('=LOG(64, 2)', 6);
+	}
+
+	test_func_lower() {
+		this._test_simple_formula('=LOWER("MiXeD")', 'mixed');
+	}
+
+	test_func_max() {
+		this._test_simple_formula('=MAX(4, 8, 5, 2)', 8);
+	}
+
+	test_func_min() {
+		this._test_simple_formula('=MIN(4, 8, 5, 2)', 2);
+	}
+
+	test_func_mod() {
+		this._test_simple_formula('=MOD(37, 4)', 1);
+	}
+
+	test_func_not() {
+		this._test_simple_formula('=NOT(TRUE)', false);
+		this._test_simple_formula('=NOT(FALSE)', true);
+	}
+
+	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);
+	}
+
+	test_func_power() {
+		this._test_simple_formula('=POWER(2, 3)', 8);
+	}
+
+	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);
+	}
+
+	test_func_sqrt() {
+		this._test_simple_formula('=SQRT(16)', 4);
+	}
+
+	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');
+	}
+
+	test_func_sum() {
+		this._test_simple_formula('=SUM(1, 2, 3, 4, 5)', 15);
+	}
+
+	test_func_upper() {
+		this._test_simple_formula('=UPPER("mIxEd")', '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);
+	}
+
+	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));
+	}
+}

jstest/spreadsheet/SpreadsheetMarkdownIntegrationTests.js

@@ -0,0 +1,62 @@
+class SpreadsheetMarkdownIntegrationTests extends BaseTest {
+	parser;
+
+	setUp() {
+		this.parser = new Markdown([ ...Markdown.allReaders, new MDSpreadsheetReader() ]);
+	}
+
+	md(markdown) {
+		return normalizeWhitespace(this.parser.toHTML(markdown));
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+}

minify.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+terser js/markdown.js --compress --mangle --output js/markdown.min.js
+terser js/spreadsheet.js --compress --mangle --output js/spreadsheet.min.js

php/markdown.php

@@ -44,7 +44,7 @@ class MDUtils {
 	 * @param int $levels
 	 * @return string|string[]
 	 */
-	public static function stripIndent(string|array &$line, int $levels=1): string|array {
+	public static function stripIndent(string|array $line, int $levels=1): string|array {
 		$regex = "^(?: {1,4}|\\t){{$levels}}";
 		return is_array($line) ? array_map(fn(string $l): string => mb_ereg_replace($regex, '', $l), $line) : mb_ereg_replace($regex, '', $line);
 	}
@@ -56,9 +56,9 @@ class MDUtils {
 	 */
 	public static function countIndents(string $line, bool $fullIndentsOnly=false): int {
 		// normalize indents to tabs
-		$t = mb_ereg_replace($fullIndentsOnly ? "(?: {4}|\\t)" : "(?: {1,4}|\\t)", "\t", $line);
+		$t = mb_ereg_replace($fullIndentsOnly ? '(?: {4}|\\t)' : '(?: {1,4}|\\t)', "\t", $line);
 		// remove content after indent
-		$t = mb_ereg_replace("^(\\t*)(.*?)$", "\\1", $t);
+		$t = mb_ereg_replace('^(\\t*)(.*?)$', '\\1', $t);
 		// count tabs
 		return mb_strlen($t);
 	}

phptest/UtilsTests.php

@@ -0,0 +1,92 @@
+<?php
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+
+require_once __DIR__ . '/../php/markdown.php';
+
+final class UtilsTests extends TestCase {
+	public function test_stripIndent() {
+		$this->assertSame('', MDUtils::stripIndent(''));
+		$this->assertSame('', MDUtils::stripIndent('  '));
+		$this->assertSame('foo', MDUtils::stripIndent('foo'));
+		$this->assertSame('foo', MDUtils::stripIndent(' foo'));
+		$this->assertSame('foo', MDUtils::stripIndent('  foo'));
+		$this->assertSame('foo', MDUtils::stripIndent('   foo'));
+		$this->assertSame('foo', MDUtils::stripIndent('    foo'));
+		$this->assertSame(' foo', MDUtils::stripIndent('     foo'));
+		$this->assertSame('foo', MDUtils::stripIndent("\tfoo"));
+		$this->assertSame("\tfoo", MDUtils::stripIndent("\t\tfoo"));
+		$this->assertSame('foo', MDUtils::stripIndent("\t\tfoo", 2));
+		$this->assertSame('foo', MDUtils::stripIndent('      foo', 2));
+	}
+
+	public function test_countIndents() {
+		$this->assertSame(0, MDUtils::countIndents(''));
+		$this->assertSame(1, MDUtils::countIndents('  '));
+		$this->assertSame(1, MDUtils::countIndents('    '));
+		$this->assertSame(0, MDUtils::countIndents('foo'));
+		$this->assertSame(0, MDUtils::countIndents('foo'));
+		$this->assertSame(1, MDUtils::countIndents(' foo'));
+		$this->assertSame(1, MDUtils::countIndents('  foo'));
+		$this->assertSame(1, MDUtils::countIndents('   foo'));
+		$this->assertSame(1, MDUtils::countIndents('    foo'));
+		$this->assertSame(2, MDUtils::countIndents('     foo'));
+		$this->assertSame(1, MDUtils::countIndents("\tfoo"));
+		$this->assertSame(2, MDUtils::countIndents("\t\tfoo"));
+
+		$this->assertSame(0, MDUtils::countIndents('', true));
+		$this->assertSame(0, MDUtils::countIndents('  ', true));
+		$this->assertSame(1, MDUtils::countIndents('    ', true));
+		$this->assertSame(0, MDUtils::countIndents('foo', true));
+		$this->assertSame(0, MDUtils::countIndents(' foo', true));
+		$this->assertSame(0, MDUtils::countIndents('  foo', true));
+		$this->assertSame(0, MDUtils::countIndents('   foo', true));
+		$this->assertSame(1, MDUtils::countIndents('    foo', true));
+		$this->assertSame(1, MDUtils::countIndents('     foo', true));
+		$this->assertSame(1, MDUtils::countIndents("\tfoo", true));
+		$this->assertSame(2, MDUtils::countIndents("\t\tfoo", true));
+	}
+
+	public function test_tokenizeLabel() {
+		// Escapes are preserved
+		$this->assertSame([ '[foo]', 'foo' ], MDToken::tokenizeLabel('[foo] bar'));
+		$this->assertSame([ '[foo\\[]', 'foo\\[' ], MDToken::tokenizeLabel('[foo\\[] bar'));
+		$this->assertSame([ '[foo\\]]', 'foo\\]' ], MDToken::tokenizeLabel('[foo\\]] bar'));
+		$this->assertSame([ '[foo[]]', 'foo[]' ], MDToken::tokenizeLabel('[foo[]] bar'));
+		$this->assertSame([ '[foo\\(]', 'foo\\(' ], MDToken::tokenizeLabel('[foo\\(] bar'));
+		$this->assertSame([ '[foo\\)]', 'foo\\)' ], MDToken::tokenizeLabel('[foo\\)] bar'));
+		$this->assertSame([ '[foo()]', 'foo()' ], MDToken::tokenizeLabel('[foo()] bar'));
+
+		$this->assertSame(null, MDToken::tokenizeLabel('foo bar'));
+		$this->assertSame(null, MDToken::tokenizeLabel('[foo\\] bar'));
+		$this->assertSame(null, MDToken::tokenizeLabel('[foo bar'));
+		$this->assertSame(null, MDToken::tokenizeLabel('[foo[] bar'));
+	}
+
+	public function test_tokenizeURL() {
+		$this->assertSame([ '(page.html)', 'page.html', null ], MDToken::tokenizeURL('(page.html) foo'));
+		$this->assertSame([ '(page.html "link title")', 'page.html', 'link title' ], MDToken::tokenizeURL('(page.html "link title") foo'));
+		$this->assertSame([ '(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->assertSame(null, MDToken::tokenizeURL('page.html foo'));
+		$this->assertSame(null, MDToken::tokenizeURL('(page.html foo'));
+		$this->assertSame(null, MDToken::tokenizeURL('page.html) foo'));
+		$this->assertSame(null, MDToken::tokenizeURL('(page.html "title) foo'));
+		$this->assertSame(null, MDToken::tokenizeURL('(page .html) foo'));
+		$this->assertSame(null, MDToken::tokenizeURL('(user@example.com) foo'));
+		$this->assertSame(null, MDToken::tokenizeURL('(user@example.com "title") foo'));
+	}
+
+	public function test_tokenizeEmail() {
+		$this->assertSame([ '(user@example.com)', 'user@example.com', null ], MDToken::tokenizeEmail('(user@example.com)'));
+		$this->assertSame([ '(user@example.com "link title")', 'user@example.com', 'link title' ], MDToken::tokenizeEmail('(user@example.com "link title")'));
+
+		$this->assertSame(null, MDToken::tokenizeEmail('(https://example.com) foo'));
+		$this->assertSame(null, MDToken::tokenizeEmail('(https://example.com "link title") foo'));
+		$this->assertSame(null, MDToken::tokenizeEmail('(user@example.com "link title) foo'));
+		$this->assertSame(null, MDToken::tokenizeEmail('(user@example.com foo'));
+		$this->assertSame(null, MDToken::tokenizeEmail('user@example.com) foo'));
+	}
+}
+?>

runphptests.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+php lib/phpunit.phar phptest/UtilsTests.php