More JS unit tests

js/markdown.js

 	static escapeHTML(str) {
 		return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 	}
+
+	/**
+	 * @param {String} email
+	 */
+	static escapeObfuscated(text) {
+		var html = '';
+		for (var p = 0; p < text.length; p++) {
+			const cp = text.codePointAt(p);
+			html += `&#${cp};`;
+		}
+		return html;
+	}
 }
 
 
 	}
 }
 
+class _MDObfuscatedTextSpan extends _MDSpan {
+	/** @param {String} text */
+	text;
+
+	/**
+	 * @param {String} text
+	 */
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+
+	toHTML(state) {
+		return _MDUtils.escapeObfuscated(this.text);
+	}
+}
+
 class _MDLinkSpan extends _MDSpan {
 	/** @var {String} */
 	link;
 	}
 
 	toHTML(state) {
-		var html = `<a href="${_MDUtils.escapeHTML(this.link)}"`;
+		var escapedLink;
+		if (this.link.startsWith('mailto:')) {
+			escapedLink = 'mailto:' + _MDUtils.escapeObfuscated(this.link.substring(7));
+		} else {
+			escapedLink = _MDUtils.escapeHTML(this.link);
+		}
+		var html = `<a href="${escapedLink}"`;
 		if (this.target) {
 			html += ` target="${_MDUtils.escapeHTML(this.target)}"`;
 		}
 	static #urlRegex = /^\((\S+?)\)/i;  // 1=URL
 	static #emailWithTitleRegex = new RegExp("^\\(\\s*(" + this.#baseEmailRegex.source + ")\\s+\"(.*?)\"\\s*\\)", "i");  // 1=email, 2=title
 	static #emailRegex = new RegExp("^\\(\\s*(" + this.#baseEmailRegex.source + ")\\s*\\)", "i");  // 1=email
-	static #simpleURLRegex = new RegExp("^<" + this.#baseURLRegex.source + ">", "i");  // 1=URL
-	static #simpleEmailRegex = new RegExp("^<" + this.#baseEmailRegex.source + ">", "i");  // 1=email
+	static #simpleURLRegex = new RegExp("^<(" + this.#baseURLRegex.source + ")>", "i");  // 1=URL
+	static #simpleEmailRegex = new RegExp("^<(" + this.#baseEmailRegex.source + ")>", "i");  // 1=email
 
 	/**
 	 * Finds a `[label]` at the start of a string. Regex was too inefficient for this.
 				endText();
 				tokens.push(new _MDToken(groups[0], _MDTokenType.Label, groups[1]));
 				p += groups[0].length - 1;
-			} else if (groups = this.#urlWithTitleRegex.exec(remainder)) {
-				// URL with title   (https://foo "Bar")
-				endText();
-				tokens.push(new _MDToken(groups[0], _MDTokenType.URL, groups[1], groups[2]));
-				p += groups[0].length - 1;
 			} else if (groups = this.#emailWithTitleRegex.exec(remainder)) {
 				// Email address with title   (user@example.com  "Foo")
 				endText();
 				tokens.push(new _MDToken(groups[0], _MDTokenType.Email, groups[1], groups[2]));
 				p += groups[0].length - 1;
-			} else if (groups = this.#urlRegex.exec(remainder)) {
-				// URL   (https://example.com)
+			} else if (groups = this.#urlWithTitleRegex.exec(remainder)) {
+				// URL with title   (https://foo "Bar")
 				endText();
-				tokens.push(new _MDToken(groups[0], _MDTokenType.URL, groups[1]));
+				tokens.push(new _MDToken(groups[0], _MDTokenType.URL, groups[1], groups[2]));
 				p += groups[0].length - 1;
 			} else if (groups = this.#emailRegex.exec(remainder)) {
 				// Email   (user@example.com)
 				endText();
 				tokens.push(new _MDToken(groups[0], _MDTokenType.Email, groups[1]));
 				p += groups[0].length - 1;
-			} else if (groups = this.#simpleURLRegex.exec(remainder)) {
-				// Simple URL   <https://example.com>
+			} else if (groups = this.#urlRegex.exec(remainder)) {
+				// URL   (https://example.com)
 				endText();
-				tokens.push(new _MDToken(groups[0], _MDTokenType.SimpleLink, groups[1]));
+				tokens.push(new _MDToken(groups[0], _MDTokenType.URL, groups[1]));
 				p += groups[0].length - 1;
 			} else if (groups = this.#simpleEmailRegex.exec(remainder)) {
 				// Simple email   <user@example.com>
 				endText();
 				tokens.push(new _MDToken(groups[0], _MDTokenType.SimpleEmail, groups[1]));
 				p += groups[0].length - 1;
+			} else if (groups = this.#simpleURLRegex.exec(remainder)) {
+				// Simple URL   <https://example.com>
+				endText();
+				tokens.push(new _MDToken(groups[0], _MDTokenType.SimpleLink, groups[1]));
+				p += groups[0].length - 1;
 			} else if (tag = this.#htmlTag(remainder)) {
 				endText();
 				tokens.push(new _MDToken(tag.fullTag, _MDTokenType.HTMLTag, tag.fullTag, null, tag));
 		// First pass - contiguous constructs
 		do {
 			anyChanges = false;
-			// ![alt](image.jpg)
+			// <https://example.com>
 			if ((index = this.#firstTokenIndex(spans, [
+				_MDTokenType.SimpleLink,
+			])) !== null) {
+				let url = spans[index].content;
+				spans.splice(index, 1, new _MDLinkSpan(url, new _MDTextSpan(url)));
+				anyChanges = true;
+			}
+
+			// <user@example.com>
+			else if ((index = this.#firstTokenIndex(spans, [
+				_MDTokenType.SimpleEmail,
+			])) !== null) {
+				let email = spans[index].content;
+				spans.splice(index, 1, new _MDLinkSpan(`mailto:${email}`, new _MDObfuscatedTextSpan(email)));
+				anyChanges = true;
+			}
+
+			// ![alt](image.jpg "title")
+			else if ((index = this.#firstTokenIndex(spans, [
 				_MDTokenType.Bang,
 				_MDTokenType.Label,
 				_MDTokenType.URL,
 				anyChanges = true;
 			}
 			
-			// [text](link.html)
+			// [text](link.html "title")
 			else if ((index = this.#firstTokenIndex(spans, [
 				_MDTokenType.Label,
 				_MDTokenType.URL,
 			])) !== null) {
 				let text = spans[index + 0].content;
 				let url = spans[index + 1].content;
-				spans.splice(index, 2, new _MDLinkSpan(url, this.#readInline(state, text)));
+				let title = spans[index + 1].extra;
+				spans.splice(index, 2, new _MDLinkSpan(url, this.#readInline(state, text), title));
+				anyChanges = true;
+			}
+
+			// [text](user@example.com "title")
+			else if ((index = this.#firstTokenIndex(spans, [
+				_MDTokenType.Label,
+				_MDTokenType.Email,
+			])) !== null) {
+				let text = spans[index + 0].content;
+				let email = spans[index + 1].content;
+				let title = spans[index + 1].extra;
+				spans.splice(index, 2, new _MDLinkSpan(`mailto:${email}`, this.#readInline(state, text), title));
 				anyChanges = true;
 			}
 

testjs.html

 		</style>
 		<script src="js/markdown.js"></script>
 		<script>
-			// TODO: Either run tests on a worker or at least on a setTimeout so
-			// UI can update and not block the thread for the whole duration.
 			function onLoad() {
 				let testClasses = [
-					MarkdownTest,
+					InlineTests,
+					BlockTests,
 				];
-				var tests = [];
-				for (const testClass of testClasses) {
-					const instance = new testClass();
-					if (!(instance instanceof BaseTest)) {
-						console.error(`${testClass.name} does not extend BaseTest`);
-						continue;
-					}
-					const testCases = TestCaseRun.findTestCases(instance);
-					tests.push(...testCases);
-					var classHTML = '<div class="testclass">';
-					classHTML += `<div class="testclassname">${testClass.name}</div>`;
-					for (const testCase of testCases) {
-						classHTML += testCase.toHTML();
-					}
-					classHTML += '</div>';
-					document.getElementById('results').innerHTML += classHTML;
-				}
-				var testInterval = setInterval(function() {
-					if (tests.length == 0) {
-						clearInterval(testInterval);
-						testInterval = null;
-						return;
-					}
-					let testCase = tests[0];
-					if (testCase.result == ResultType.testing) {
-						tests.splice(0, 1);
-						testCase.updateHTML();
-						testCase.run();
-						testCase.updateHTML();
-					} else {
-						testCase.result = ResultType.testing;
-						testCase.updateHTML();
-					}
-				}, 1);
+				TestClassRunner.runAll(testClasses);
 			}
 
 			/**
 			class BaseTest {
 				setUp() {}
 				tearDown() {}
-				/** @var {TestCaseRun|null} */
+				/** @var {TestCaseRunner|null} */
 				currentRunner = null;
 				fail(failMessage=null) {
 					throw new FailureError(failMessage || 'failed');
 				}
 			}
 
-			class TestCaseRun {
+			/**
+			 * Manages the running and results of a single test method on a test
+			 * class.
+			 */
+			class TestCaseRunner {
+				/** @var {number} */
 				static #nextUniqueId = 1;
+				/** @var {number} */
+				uniqueId = 0;
 				/** @var {BaseTest} */
 				#objectUnderTest;
 				/** @var {method} */
 				#method;
-				uniqueId = 0;
 				/** @var {ResultType} */
 				result = ResultType.untested;
 				/** @var {String|null} */
 				constructor(objectUnderTest, method) {
 					this.#objectUnderTest = objectUnderTest;
 					this.#method = method;
-					this.uniqueId = TestCaseRun.#nextUniqueId++;
+					this.uniqueId = TestCaseRunner.#nextUniqueId++;
 				}
 				run() {
 					try {
 						}
 					}
 				}
+				get #cssId() { return `testcase${this.uniqueId}`; }
 				#isExpectedError(e) {
 					if (this.expectedError === null) return false;
 					if (this.expectedError === true) return true;
 					return false;
 				}
 				toHTML() {
-					var html = `<div class="testcase" id="testcase${this.uniqueId}">`;
+					var html = `<div class="testcase" id="${this.#cssId}">`;
 					html += `<div class="testcasename"><span class="testcaseclass">${this.className}</span>.<span class="testcasemethod">${this.methodName}</span></div>`;
 					switch (this.result) {
 						case ResultType.untested:
 					html += `</div>`;
 					return html;
 				}
+				/**
+				 * Updates the HTML node in-place with the current status, or
+				 * adds it if it does not exist yet.
+				 */
 				updateHTML() {
-					let existing = document.getElementById(`testcase${this.uniqueId}`);
+					let existing = document.getElementById(this.#cssId);
 					if (existing) {
 						existing.outerHTML = this.toHTML();
 					} else {
 				}
 
 				/**
-				 * @param {object} instance
-				 * @returns {TestCaseRun[]}
+				 * @param {object} objectUnderTest
+				 * @returns {TestCaseRunner[]}
 				 */
-				static findTestCases(instance) {
-					if (!(instance instanceof BaseTest)) return [];
+				static findTestCases(objectUnderTest) {
+					if (!(objectUnderTest instanceof BaseTest)) return [];
 					var members = [];
-					var obj = instance;
+					var obj = objectUnderTest;
 					do {
 						members.push(...Object.getOwnPropertyNames(obj));
 					} while (obj = Object.getPrototypeOf(obj));
 					return members.sort().filter((e, i, arr) => {
-						if (e != arr[i + 1] && typeof instance[e] == 'function' && e.startsWith('test')) return true;
+						if (e != arr[i + 1] && typeof objectUnderTest[e] == 'function' && e.startsWith('test')) return true;
 					}).map((name) => {
-						return new TestCaseRun(instance, instance[name]);
+						return new TestCaseRunner(objectUnderTest, objectUnderTest[name]);
 					});
 				}
 			}
 
-			class MarkdownTest extends BaseTest {
+			class TestClassRunner {
+				static #nextUniqueId = 1;
+
+				#uniqueId = 0;
+				#theClass;
+				#instance;
+				#testCases;
+
+				get testCases() { return this.#testCases; }
+
+				constructor(theClass) {
+					this.#theClass = theClass;
+					this.#instance = new theClass();
+					this.#testCases = TestCaseRunner.findTestCases(this.#instance);
+					this.#uniqueId = TestClassRunner.#nextUniqueId++;
+				}
+				get #cssId() { return `testclass${this.#uniqueId}`; }
+				toHTML() {
+					var html = '';
+					html += `<div class="testclass" id="${this.#cssId}">`;
+					html += `<div class="testclassname">${this.#theClass.name}</div>`;
+					for (const testCase of this.#testCases) {
+						html += testCase.toHTML();
+					}
+					html += '</div>';
+					return html;
+				}
+				updateHTML() {
+					var existing = document.getElementById(this.#cssId);
+					if (!existing) {
+						document.getElementById('results').innerHTML += this.toHTML();
+					}
+				}
+
+				static runAll(testClasses) {
+					var tests = [];  // tuples of TestClassRunner and TestCaseRunner
+					for (const testClass of testClasses) {
+						const classRunner = new TestClassRunner(testClass);
+						classRunner.updateHTML();
+						tests.push(...classRunner.testCases.map(function(test) { return [ classRunner, test ] }));
+					}
+					var testInterval = setInterval(function() {
+						if (tests.length == 0) {
+							clearInterval(testInterval);
+							testInterval = null;
+							return;
+						}
+						var classRunner;
+						var testCase;
+						[ classRunner, testCase ] = tests[0];
+						if (testCase.result == ResultType.untested) {
+							testCase.result = ResultType.testing;
+							testCase.updateHTML();
+							classRunner.updateHTML();
+						} else if (testCase.result == ResultType.testing) {
+							tests.splice(0, 1);
+							testCase.run();
+							testCase.updateHTML();
+							classRunner.updateHTML();
+						}
+					}, 1);
+				}
+			}
+
+			// ---------------------------------------------------------------
+
+			function normalizeWhitespace(str) {
+				return str.replace(/\s+/g, ' ').replace(/(?:^\s+|\s+$)/g, '');
+			}
+
+			class InlineTests extends BaseTest {
 				test_simpleSingleParagraph() {
 					let markdown = 'Lorem ipsum';
 					let expected = '<p>Lorem ipsum</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 				test_strong() {
 					let markdown = 'Lorem **ipsum** dolor **sit**';
 					let expected = '<p>Lorem <strong>ipsum</strong> dolor <strong>sit</strong></p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 				test_emphasis() {
 					let markdown = 'Lorem _ipsum_ dolor _sit_';
 					let expected = '<p>Lorem <em>ipsum</em> dolor <em>sit</em></p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 				test_strongEmphasis_easy() {
 					let markdown = 'Lorem **ipsum *dolor* sit** amet';
 					let expected = '<p>Lorem <strong>ipsum <em>dolor</em> sit</strong> amet</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 					let markdown = 'Lorem ***ipsum*** dolor';
 					let expected1 = '<p>Lorem <strong><em>ipsum</em></strong> dolor</p>';
 					let expected2 = '<p>Lorem <em><strong>ipsum</strong></em> dolor</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertTrue(actual == expected1 || actual == expected2);
 				}
 
 				test_strongEmphasis_hard1() {
 					let markdown = 'Lorem ***ipsum* dolor** sit';
 					let expected = '<p>Lorem <strong><em>ipsum</em> dolor</strong> sit</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 				test_strongEmphasis_hard2() {
 					let markdown = 'Lorem ***ipsum** dolor* sit';
 					let expected = '<p>Lorem <em><strong>ipsum</strong> dolor</em> sit</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 				test_inlineCode() {
 					let markdown = 'Lorem `ipsum` dolor';
 					let expected = '<p>Lorem <code>ipsum</code> dolor</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 
 				test_inlineCode_withInnerBacktick() {
 					let markdown = 'Lorem ``ip`su`m`` dolor';
 					let expected = '<p>Lorem <code>ip`su`m</code> dolor</p>';
-					let actual = Markdown.toHTML(markdown).trim();
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_strikethrough_single() {
+					let markdown = 'Lorem ~ipsum~ dolor';
+					let expected = '<p>Lorem <strike>ipsum</strike> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_strikethrough_double() {
+					let markdown = 'Lorem ~~ipsum~~ dolor';
+					let expected = '<p>Lorem <strike>ipsum</strike> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_fullyQualified() {
+					let markdown = 'Lorem [ipsum](https://example.com/path/page.html) dolor';
+					let expected = '<p>Lorem <a href="https://example.com/path/page.html">ipsum</a> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_relative() {
+					let markdown = 'Lorem [ipsum](page.html) dolor';
+					let expected = '<p>Lorem <a href="page.html">ipsum</a> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_title() {
+					let markdown = 'Lorem [ipsum](page.html "link title") dolor';
+					let expected = '<p>Lorem <a href="page.html" title="link title">ipsum</a> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_literal() {
+					let markdown = 'Lorem <https://example.com> dolor';
+					let expected = '<p>Lorem <a href="https://example.com">https://example.com</a> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_email() {
+					let markdown = 'Lorem [ipsum](user@example.com) dolor';
+					let expected = '<p>Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">ipsum</a> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_email_withTitle() {
+					let markdown = 'Lorem [ipsum](user@example.com "title") dolor';
+					let expected = '<p>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</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_literalEmail() {
+					let markdown = 'Lorem <user@example.com> dolor';
+					let expected = '<p>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</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_image() {
+					let markdown = 'Lorem ![alt text](image.jpg) dolor';
+					let expected = '<p>Lorem <img src="image.jpg" alt="alt text"> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_image_noAlt() {
+					let markdown = 'Lorem ![](image.jpg) dolor';
+					let expected = '<p>Lorem <img src="image.jpg"> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_image_withTitle() {
+					let markdown = 'Lorem ![alt text](image.jpg "image title") dolor';
+					let expected = '<p>Lorem <img src="image.jpg" alt="alt text" title="image title"> dolor</p>';
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+			}
+
+			class BlockTests extends BaseTest {
+				test_paragraphs() {
+					let markdown = "Lorem ipsum\n\nDolor sit amet";
+					let expected = "<p>Lorem ipsum</p> <p>Dolor sit amet</p>";
+					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					this.assertEqual(actual, expected);
+				}
+
+				test_paragraph_lineGrouping() {
+					let markdown = "Lorem ipsum\ndolor sit amet";
+					let expected = "<p>Lorem ipsum dolor sit amet</p>";
+					let actual = normalizeWhitespace(Markdown.toHTML(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 = normalizeWhitespace(Markdown.toHTML(markdown));
 					this.assertEqual(actual, expected);
 				}
 			}