index : cgit

-- Unit checks for custom/extensions/about-render.lua, run under a standalone
-- Lua by t0501-about-render.sh with the script path as the first argument.
-- The second argument is the mode. In lpeg mode, which t0501 asks for only
-- where the interpreter has lpeg, the markdown and man checks run. In nolpeg
-- mode the lpeg module fails to load, so the escaped plain text fallback is
-- proven even on a machine where lpeg is installed.

local test_directory = arg[0]:match("^(.*)/") or "."
local h = dofile(test_directory .. "/harness.lua")

local script = arg[1]
local mode = h.mode("lpeg", "nolpeg")

if mode == "nolpeg" then
	h.preload_failure("lpeg")
end

h.load(script)

-- A missing lpeg is written to the error log as the script loads.
if mode == "nolpeg" then
	h.equals("a missing lpeg is named in the error log", h.error_log(),
		"[cgit] Unable to load lpeg, so markdown and man pages show as plain text\n")
else
	h.equals("with lpeg the error log stays empty", h.error_log(), "")
end

local function render(filename, text)
	return h.run({ filename }, { text })
end

-- A readme tracked in a repository comes with the url of its tree.
local function render_tree(filename, query, text)
	return h.run({ filename, "/r/tree/", query }, { text })
end

-- Dispatch and the plain text rendering need nothing but the script itself,
-- so they run whatever became of lpeg.

local out, ret = render("README", "plain <text> & more")
h.contains("no extension renders as plain text", out,
	"<pre class='plaintext'>plain &lt;text&gt; &amp; more</pre>")
h.equals("close answers zero", ret, 0)

out = render("notes.txt", "just text")
h.contains("an unknown extension renders as plain text", out, "<pre class='plaintext'>just text</pre>")

out = render(nil, "no name at all")
h.contains("a missing filename renders as plain text", out,
	"<pre class='plaintext'>no name at all</pre>")

-- cgit's C sink stops at the first NUL byte, so the script replaces each one
-- before anything is written, and the text past it survives.
out = render("README", "before\0after\0")
h.contains("a nul byte shows as a replacement character", out,
	"<pre class='plaintext'>before\239\191\189after\239\191\189</pre>")

out = h.run({ "README" }, { "two ", "writes" })
h.contains("writes are joined before rendering", out, "two writes")

if mode == "nolpeg" then
	out = render("README.md", "# Title")
	h.contains("markdown without lpeg falls back to plain text", out, "<pre class='plaintext'># Title</pre>")
	out = render("page.1", ".SH NAME")
	h.contains("man without lpeg falls back to plain text", out, "<pre class='plaintext'>.SH NAME</pre>")
	h.finish()
end

-- Markdown.

out = render("README.md", "# Title")
h.contains("a heading renders inside the wrapper", out, "<div class='markdown'><h1 id='title'>Title</h1></div>")

out = render("README.md", "## Sub ##")
h.contains("trailing hashes are stripped from a heading", out, "<h2 id='sub'>Sub</h2>")

out = render("README.md", "# C#")
h.contains("a hash ending a word stays in the heading", out, "<h1 id='c'>C#</h1>")

out = render("README.md", "## The `run` [Command](x), Again!")
h.contains("an anchor is the heading's text in lower case", out, "<h2 id='the-run-command-again'>")

out = render("README.md", "# Twice\n# Twice\n# twice")
h.contains("a repeated anchor is counted", out, "<h1 id='twice'>Twice</h1><h1 id='twice-1'>Twice</h1><h1 id='twice-2'>")

out = render("README.md", "# About")
h.contains("no heading takes an id of the page", out, "<h1 id='about-1'>")

out = render("README.md", "# Cgit\n# Header")
h.contains("nor any other id of the page", out, "<h1 id='cgit-1'>Cgit</h1><h1 id='header-1'>Header</h1>")

out = render("README.md", "# Twice\n# Twice\n# Twice 1")
h.contains("a count never gives an anchor a heading already took", out,
	"<h1 id='twice-1'>Twice</h1><h1 id='twice-1-1'>Twice 1</h1>")

out = render("README.md", "# About\n# About 1")
h.contains("and the same holds past an id of the page", out, "<h1 id='about-1'>About</h1><h1 id='about-1-1'>About 1</h1>")

out = render("README.md", "# ???")
h.contains("a heading of punctuation gets no anchor", out, "<h1>???</h1>")

out = render("README.MD", "# Upper")
h.contains("the extension matches whatever its case", out, "<h1 id='upper'>Upper</h1>")

out = render("readme.markdown", "# Long")
h.contains("the long markdown extension dispatches too", out, "<h1 id='long'>Long</h1>")

out = render("README.md", "line one\nline two")
h.contains("the lines of a paragraph run together", out, "<p>line one\nline two</p>")

out = render("README.md", "first para\r\nsecond line")
h.contains("crlf line endings are normalised", out, "<p>first para\nsecond line</p>")

out = render("README.md", "one  \ntwo\\\nthree")
h.contains("two trailing spaces break the line", out, "<p>one<br>\ntwo")
h.contains("a trailing backslash breaks the line", out, "two<br>\nthree</p>")

out = render("README.md", "spaces  \n\nslash\\")
h.contains("the last line takes no break", out, "<p>spaces</p><p>slash\\</p>")

out = render("README.md", "a **bold** and *leaning* word")
h.contains("double stars embolden", out, "<strong>bold</strong>")
h.contains("single stars lean", out, "<em>leaning</em>")

out = render("README.md", "an __up__ and _down_ word")
h.contains("double underscores embolden", out, "<strong>up</strong>")
h.contains("single underscores lean", out, "<em>down</em>")

out = render("README.md", "snake_case_name and _lean_ and foo__bar__")
h.contains("underscores inside words stay literal", out, "<p>snake_case_name and <em>lean</em> and foo__bar__</p>")

out = render("README.md", "_a_b_ and __c_d__")
h.contains("emphasis spans an underscore inside a word", out, "<p><em>a_b</em> and <strong>c_d</strong></p>")

out = render("README.md", "\\*not leaning\\* and \\# and \\q")
h.contains("a backslash makes punctuation literal", out, "<p>*not leaning* and # and \\q</p>")

out = render("README.md", "\\# not a heading")
h.contains("an escaped hash starts no heading", out, "<p># not a heading</p>")

out = render("README.md", "`a\\*b`")
h.contains("code keeps its backslashes", out, "<code>a\\*b</code>")

out = render("README.md", "&copy; &#169; &#xA9; &amp;")
h.contains("character references pass through", out, "<p>&copy; &#169; &#xA9; &amp;</p>")

out = render("README.md", "AT&T & &#xZZ; &#12345678;")
h.contains("a bare ampersand is escaped", out, "<p>AT&amp;T &amp; &amp;#xZZ; &amp;#12345678;</p>")

out = render("README.md", "`&amp;`")
h.contains("code shows a reference as written", out, "<code>&amp;amp;</code>")

out = render("README.md", "run `x < y` here")
h.contains("inline code is escaped", out, "<code>x &lt; y</code>")

out = render("README.md", "raw <script>alert(1)</script> here")
h.contains("markup in text reaches the page escaped", out, "&lt;script&gt;alert(1)&lt;/script&gt;")
h.excludes("no live tag slips through", out, "<script>")

out = render("README.md", "[docs](https://example.com/docs)")
h.contains("an https link renders as an anchor", out, "<a href='https://example.com/docs'>docs</a>")

out = render("README.md", "[docs](docs/page.html)")
h.contains("with no tree a relative link stays as written", out, "<a href='docs/page.html'>docs</a>")

out = render_tree("README.md", "", "[road](ROADMAP.md)")
h.contains("a relative link leads into the tree", out, "<a href='/r/tree/ROADMAP.md'>road</a>")

out = render_tree("docs/README.md", "", "[a](guide.md#setup) [b](../NEWS) [c](/src/x.c)")
h.contains("a link resolves against the readme's directory", out, "href='/r/tree/docs/guide.md#setup'")
h.contains("dot segments fold", out, "href='/r/tree/NEWS'")
h.contains("a leading slash names the root", out, "href='/r/tree/src/x.c'")

out = render_tree("docs/README.md", "", "[up](../../../etc/passwd)")
h.contains("no link climbs above the root", out, "href='/r/tree/etc/passwd'")

out = render_tree("README.md", "?h=next", "[a](NEWS#top)")
h.contains("the ref's query comes before the fragment", out, "href='/r/tree/NEWS?h=next#top'")

out = render_tree("README.md", "&h=next", "[a](NEWS)")
h.contains("the query is escaped for the attribute", out, "href='/r/tree/NEWS&amp;h=next'")

out = render_tree("README.md", "", "[a](x.md#'<b>)")
h.contains("a fragment is escaped for the attribute", out, "href='/r/tree/x.md#&#x27;&lt;b&gt;'")

out = render_tree("README.md", "", "[a](my%20file.md) [b](a&b.md) [c](f.md?plain=1)")
h.contains("an encoded path is encoded only once", out, "href='/r/tree/my%20file.md'")
h.contains("a path is escaped for the url", out, "href='/r/tree/a%26b.md'")
h.contains("a query in a link is dropped", out, "href='/r/tree/f.md'")

out = render_tree("README.md", "", "[a](x%00y)")
h.contains("an encoded nul stays encoded", out, "href='/r/tree/x%2500y'")

out = render_tree("README.md", "", "[a](#usage) [b](https://example.com/x)")
h.contains("a fragment stays on the page", out, "href='#usage'")
h.contains("an absolute link is left alone", out, "href='https://example.com/x'")

out = render("README.md", "[mail](mailto:a@example.com)")
h.contains("a mailto link renders as an anchor", out, "<a href='mailto:a@example.com'>mail</a>")

out = render("README.md", "see <https://example.com/a?b=1> or <me@example.com>")
h.contains("a url in angle brackets links", out, "<a href='https://example.com/a?b=1'>https://example.com/a?b=1</a>")
h.contains("an address in angle brackets links", out, "<a href='mailto:me@example.com'>me@example.com</a>")

out = render("README.md", "<javascript:alert(1)> and <b>")
h.excludes("an unsafe autolink renders no anchor", out, "<a ")
h.contains("other angle brackets stay text", out, "&lt;b&gt;")

out = render("README.md", "[bad](javascript:alert(1))")
h.excludes("a javascript link renders no anchor", out, "<a ")
h.contains("its text still reaches the page", out, "bad")

-- A target cannot span lines, so a control byte is what could hide its
-- scheme, and a browser drops one that comes before it.
out = render("README.md", "[bad](\1javascript:alert%281%29)")
h.excludes("a control byte before a scheme is still caught", out, "<a ")
h.contains("and only the text reaches the page", out, "<p>bad</p>")

out = render("README.md", "[bad](java\1script:alert%281%29)")
h.excludes("a control byte inside a scheme is still caught", out, "<a ")
h.contains("and only that text reaches the page", out, "<p>bad</p>")

out = render("README.md", "[bad](//evil.example/x)")
h.excludes("a scheme relative link renders no anchor", out, "<a ")
h.contains("and only its text reaches the page", out, "<p>bad</p>")

out = render("README.md", "[q](https://example.com/a'b)")
h.contains("a quote in a link target is escaped", out, "href='https://example.com/a&#x27;b'")

out = render("README.md", "an ![a & b](https://example.com/i.png) image")
h.contains("an image is left out", out, "<p>an  image</p>")

out = render("README.md", "a [![ci](https://ci.example/b.svg)](https://ci.example/) badge")
h.contains("a badge is left out with its link", out, "<p>a  badge</p>")

out = render("README.md", "[![a](x.svg)](y)\n![b](z.svg)\n\ntext")
h.contains("a paragraph of badges leaves nothing behind", out, "<div class='markdown'><p>text</p></div>")

out = render("README.md", "```lua\nlocal x = 1 < 2\n```\nafter")
h.contains("a fenced block renders as code", out, "<pre><code>local x = 1 &lt; 2\n</code></pre>")
h.contains("text after the fence renders on", out, "<p>after</p>")

out = render("README.md", "~~~\n**not bold**\n~~~")
h.contains("no inline parsing happens inside a fence", out, "<code>**not bold**\n</code>")

out = render("README.md", "---")
h.contains("a rule of dashes renders a break", out, "<hr>")

out = render("README.md", "- - -")
h.contains("a spaced rule renders a break too", out, "<hr>")

out = render("README.md", "> quoted words")
h.contains("a quote renders as a blockquote", out, "<blockquote><p>quoted words</p></blockquote>")

out = render("README.md", "> > deep")
h.contains("quotes nest", out, "<blockquote><blockquote><p>deep</p></blockquote></blockquote>")

-- A hostile readme of stacked markers has to hit the depth ceiling instead
-- of the interpreter's stack.
out = render("README.md", string.rep("> ", 30) .. "x")
local _, quote_count = out:gsub("<blockquote>", "")
h.equals("quote nesting stops at the ceiling", quote_count, 24)
h.contains("the markers past it stay as text", out, "<p>&gt; &gt; &gt; &gt; &gt; x</p>")

-- Each kind of emphasis can hold the others but not itself, so inline
-- markup nests only a few levels deep and never reaches its ceiling.
out = render("README.md", "**__*_x_*__**")
h.contains("every kind of emphasis nests in the others", out,
	"<p><strong><strong><em><em>x</em></em></strong></strong></p>")

-- A hostile readme must cost about four times as much at four times the
-- length, as a linear pass does, where a quadratic one costs sixteen times
-- as much and holds a request for minutes near the size cap. Timing one
-- length against the other cancels out how fast the host is, and each
-- render repeats until it is long enough to time.
local function seconds(filename, text)
	local runs, started, out = 0, os.clock(), nil
	repeat
		out = render(filename, text)
		runs = runs + 1
	until os.clock() - started >= 0.02
	return (os.clock() - started) / runs, out
end

local function stays_linear(name, filename, make, length)
	local short = seconds(filename, make(length))
	local long, out = seconds(filename, make(4 * length))
	h.check(name, long < 10 * short,
		string.format("%.4f s at length %d, then %.4f s at four times that", short, length, long))
	h.equals(name .. " and still renders as markup", out:sub(1, 22), "<div class='markdown'>")
end

local function repeated(unit)
	return function(count)
		return string.rep(unit, count)
	end
end

-- Lua patterns backtrack, which is why trim finds each end directly.
stays_linear("a long run of spaces in a heading is trimmed in linear time", "README.md",
	function(count) return "# a" .. string.rep(" ", count) .. "b" end, 10000)
stays_linear("a long run of spaces in a table cell is trimmed in linear time", "README.md",
	function(count) return "| a | b |\n|---|---|\n| x" .. string.rep(" ", count) .. "y | z |" end, 10000)

-- Every repeat of a heading counts up from the same anchor.
stays_linear("the anchors of a repeated heading are counted in linear time", "README.md",
	repeated("# a\n"), 12500)

-- Without the cap on the label and target scans, every unclosed bracket
-- scans to the end of its line.
stays_linear("a line of open brackets is scanned in linear time", "README.md", repeated("["), 10000)
stays_linear("a line of unclosed links is scanned in linear time", "README.md", repeated("[a](b"), 10000)

-- The long forms of the man escapes scan for a closing bracket, bounded the
-- same way.
stays_linear("a line of unclosed character names renders in linear time", "page.1", repeated("\\["), 10000)
stays_linear("a line of unclosed font names renders in linear time", "page.1", repeated("\\f["), 10000)
stays_linear("a line of unclosed size escapes renders in linear time", "page.1", repeated("\\s["), 10000)

out = render("README.md", "Title\n=====\n\nBody")
h.contains("equals signs under a line make a heading", out, "<h1 id='title'>Title</h1><p>Body</p>")

out = render("README.md", "Two\nlines\n---\nafter")
h.contains("dashes under a paragraph make a heading of it all", out,
	"<h2 id='two-lines'>Two lines</h2><p>after</p>")

out = render("README.md", "text\n***\nmore")
h.contains("a rule ends the paragraph above it", out, "<p>text</p><hr><p>more</p>")

out = render("README.md", "Para\n\n    code line\n\tnext <line>\n\nafter")
h.contains("an indented block renders as code", out,
	"<p>Para</p><pre><code>code line\nnext &lt;line&gt;\n</code></pre><p>after</p>")

out = render("README.md", "- item\n\n    more about it")
h.excludes("an indented paragraph after a list stays prose", out, "<pre>")
h.contains("and renders as a paragraph", out, "<p>more about it</p>")

out = render("README.md", "[a](\\\\evil.example/x) [b](\\/evil.example/x)")
h.excludes("a scheme relative link spelt with backslashes renders no anchor", out, "<a ")
h.contains("and only their text reaches the page", out, "<p>a b</p>")

out = render("README.md", "| a | b |\n| --- | --- |\n| 1 | 2 |")
h.contains("a pipe table renders its head", out, "<thead><tr><th>a</th><th>b</th></tr></thead>")
h.contains("a pipe table renders its body", out, "<tbody><tr><td>1</td><td>2</td></tr></tbody>")

out = render("README.md", "Pick one:\n| a | b |\n|---|---|\n| 1 | 2 |")
h.contains("a table cuts a paragraph short", out, "<p>Pick one:</p><table><thead><tr><th>a</th>")

out = render("README.md", "a | b in prose")
h.excludes("a pipe without a delimiter row stays prose", out, "<table")
h.contains("and renders as a paragraph", out, "<p>a | b in prose</p>")

out = render("README.md", "| a | b |\n|---|---|\n| x \\| y | `p \\| q` |")
h.contains("an escaped pipe stays in its cell", out, "<td>x | y</td><td><code>p | q</code></td>")

out = render("README.md", "| a | b |\n|---|---|\n| x \\\\| y |")
h.contains("an escaped backslash still lets the pipe divide", out, "<td>x \\</td><td>y</td>")

out = render("README.md", "- first\n- second")
h.contains("dashes render an unordered list", out, "<ul><li>first</li><li>second</li></ul>")

out = render("README.md", "1. first\n2. second")
h.contains("numbers render an ordered list", out, "<ol><li>first</li><li>second</li></ol>")

out = render("README.md", "1. first\n\n2. second\n\n3. third")
h.contains("a list split by blank lines keeps counting", out,
	"<ol><li>first</li></ol><ol start='2'><li>second</li></ol><ol start='3'><li>third</li></ol>")

out = render("README.md", "07) seventh\n08) eighth")
h.contains("a list that opens past one starts there", out, "<ol start='7'><li>seventh</li><li>eighth</li></ol>")

out = render("README.md", "- one\n  wrapped\n- two")
h.contains("a wrapped item stays one item", out, "<ul><li>one\nwrapped</li><li>two</li></ul>")

out = render("README.md", "1. step\nlazy line\n2. next")
h.contains("an unindented line carries the item on", out, "<ol><li>step\nlazy line</li><li>next</li></ol>")

out = render("README.md", "- item\n---")
h.contains("a rule still ends the list", out, "<ul><li>item</li></ul><hr>")

out = render("README.md", "- plain\n1. numbered")
h.contains("a change of marker splits the list", out, "</ul><ol>")

out = render("README.md", "- a **bold** item")
h.contains("list items parse their text", out, "<li>a <strong>bold</strong> item</li>")

out = render("README.md", "1. a\n```\nx\n```\n2. b")
h.contains("a list split by a code block keeps counting", out,
	"<ol><li>a</li></ol><pre><code>x\n</code></pre><ol start='2'><li>b</li></ol>")

out = render("README.md", "+ a\n+ b")
h.contains("plus signs render an unordered list", out, "<ul><li>a</li><li>b</li></ul>")

out = render("README.md", "* a\n* b")
h.contains("stars render an unordered list", out, "<ul><li>a</li><li>b</li></ul>")

out = render("README.md", "### c\n#### d\n##### e\n###### f\n####### g")
h.contains("headings go down to the sixth level and no further", out,
	"<h3 id='c'>c</h3><h4 id='d'>d</h4><h5 id='e'>e</h5><h6 id='f'>f</h6><p>####### g</p>")

out = render("x.mkd", "# M")
h.contains("the mkd extension dispatches too", out, "<h1 id='m'>M</h1>")

out = render("x.mdown", "# M")
h.contains("and so does mdown", out, "<h1 id='m'>M</h1>")

out = render("README.md", "a\rb")
h.contains("a bare carriage return ends a line", out, "<p>a\nb</p>")

out = render("README.md", "a | b\n:--- | ---:\n1 | 2")
h.contains("a delimiter row needs no outer pipes and may carry colons", out,
	"<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>")

out = render("README.md", "| a | b |\n|:-:|--:|\n| 1 | 2 |")
h.contains("a centred or right aligned column still makes a table", out,
	"<tbody><tr><td>1</td><td>2</td></tr></tbody>")

out = render("README.md", "| a | b |\n|---|---|\n| 1 |\n| 1 | 2 | 3 |")
h.contains("a row shorter or longer than the head keeps every cell", out,
	"<tbody><tr><td>1</td></tr><tr><td>1</td><td>2</td><td>3</td></tr></tbody>")

out = render("README.md", "```\ncode\nmore")
h.contains("an unclosed fence runs to the end", out,
	"<div class='markdown'><pre><code>code\nmore\n</code></pre></div>")

out = render("README.md", '[a](x "t")')
h.contains("a link title is dropped", out, "<p><a href='x'>a</a></p>")

out = render("README.md", "# a <b>\n\n- <b>\n\n> <b>\n\n[<b>](x)\n\n| <b> |\n|---|\n| <i> |")
h.contains("markup in a heading is escaped", out, "<h1 id='a-b'>a &lt;b&gt;</h1>")
h.contains("markup in a list item is escaped", out, "<li>&lt;b&gt;</li>")
h.contains("markup in a quote is escaped", out, "<blockquote><p>&lt;b&gt;</p></blockquote>")
h.contains("markup in link text is escaped", out, "<a href='x'>&lt;b&gt;</a>")
h.contains("markup in a table head is escaped", out, "<th>&lt;b&gt;</th>")
h.contains("markup in a table cell is escaped", out, "<td>&lt;i&gt;</td>")

out = render("README.md", string.rep("a", 512 * 1024 + 1))
h.contains("an oversized readme renders as plain text", out, "<pre class='plaintext'>")

out = render("README.md", string.rep("a", 512 * 1024))
h.equals("a readme of exactly the cap still renders as markup", out:sub(1, 25), "<div class='markdown'><p>")

-- Man pages.

out = render("page.1", ".SH NAME")
h.contains("a section heading renders", out, "<div class='markdown'><h2 id='name'>NAME</h2></div>")

out = render("page.man", '.SH "TWO WORDS"')
h.contains("a quoted heading argument is unquoted", out, "<h2 id='two-words'>TWO WORDS</h2>")

out = render("page.3", ".SS Details")
h.contains("a subsection renders one level down", out, "<h3 id='details'>Details</h3>")

out = render("page.1", ".B bold words\nplain after")
h.contains("the bold macro renders strong", out, "<p><strong>bold words</strong>\nplain after</p>")

out = render("page.1", "a \\fBbold\\fR c")
h.contains("font escapes carry across a run", out, "<p>a <strong>bold</strong> c</p>")

out = render("page.1", "x \\(em y \\- z \\(bu \\[co]")
h.contains("character escapes are translated", out, "<p>x — y - z • ©</p>")

out = render("page.1", "\\*(lqquoted\\*(rq\\*R")
h.contains("predefined strings are expanded", out, "<p>“quoted”®</p>")

out = render("page.1", "a\\%b c\\:d \\s-1SMALL\\s0 text \\\" a comment")
h.contains("escapes that only steer the layout draw nothing", out, "<p>ab cd SMALL text </p>")

out = render("page.1", ".nf\ncode <x>\n.fi\nafter")
h.contains("a no fill block renders as code", out, "<pre><code>code &lt;x&gt;\n</code></pre>")
h.contains("filling resumes after it", out, "<p>after</p>")

out = render("page.1", ".nf\n\\fBgit\\fR \\-\\-version\n.fi")
h.contains("a no fill block shows the text of its escapes", out, "<pre><code>git --version\n</code></pre>")

out = render("page.1", ".EX\nline <one>\n.EE")
h.contains("an example block renders as code", out, "<pre><code>line &lt;one&gt;\n</code></pre>")

out = render("page.1", ".TP\n.B \\-v\nBe verbose.")
h.contains("a tag takes a line of its own", out, "<p><strong>-v</strong><br>\nBe verbose.</p>")

out = render("page.1", ".IP \\(bu 2\nAn item.\n.IP \\-v 4\nA flag.")
h.contains("a bullet leads its item", out, "<p>• \nAn item.</p>")
h.contains("a longer tag takes a line of its own", out, "<p>-v<br>\nA flag.</p>")

out = render("page.1", ".BR ls (1),\n.IR file .txt")
h.contains("alternating macros switch fonts between arguments", out,
	"<strong>ls</strong>(1),\n<em>file</em>.txt")

out = render("page.1", '.B "two words" three')
h.contains("a quoted argument keeps its blank", out, "<strong>two words three</strong>")

out = render("page.1", "one\n.br\ntwo\n.\nthree")
h.contains("a break request breaks the line", out, "<p>one<br>\ntwo\nthree</p>")

-- pod2man and asciidoctor open their pages with macro definitions and
-- conditional requests, none of which may reach the page as text.
out = render("page.1", table.concat({
	".de Vb", ".nf", "..", ".de IX", "..", ".if n .ds Aq '", ".ie \\n(.g \\{\\",
	".  nr x 1", ".\\}", ".SH NAME", ".IX Header \"NAME\"", ".Vb 2", "\\&  code", ".Ve", "after",
}, "\n"))
h.excludes("a page's own macro is not drawn", out, "Header")
h.excludes("a roff request is not drawn", out, "Aq")
h.contains("the heading after the preamble renders", out, "<h2 id='name'>NAME</h2>")
h.contains("pod2man's verbatim macros render code", out, "<pre><code>  code\n</code></pre>")
h.contains("text after the definitions renders", out, "<p>after</p>")

out = render("page.1", ".if n \\\n\\{\\\n.ds x y\n.\\}\nafter")
h.contains("a conditional block's requests and braces draw nothing", out,
	"<div class='markdown'><p>after</p></div>")

out = render("page.1", "The \\m[blue]\\fBManual\\fR\\m[]\\s-2\\u[1]\\d\\s+2 here")
h.contains("DocBook's link colours and footnote marks draw nothing", out,
	"<p>The <strong>Manual</strong>[1] here</p>")

out = render("page.1", ".de x\n.B hidden\n..  \nshown")
h.contains("a definition ends at two dots with blanks after them", out,
	"<div class='markdown'><p>shown</p></div>")

out = render("page.1", ".TP\n.PD 0\n.B \\-a\nall\n.PD\nDon\\*(Aqt")
h.equals("a spacing macro draws nothing and the apostrophe string expands", out,
	"<div class='markdown'><p><strong>-a</strong><br>\nall\nDon't</p></div>")

out = render("page.1", '.\\" a comment\nvisible')
h.excludes("a roff comment is dropped", out, "comment")
h.contains("the line after it renders", out, "visible")

out = render("page.1", "first\n\nsecond")
h.contains("a blank line splits paragraphs", out, "<p>first</p><p>second</p>")

out = render("page.1", ".TH title 1\nbody")
h.excludes("the title macro renders nothing itself", out, "title 1")
h.contains("the body after it renders", out, "<p>body</p>")

-- A parse that fails falls back to escaped plain text, and an emit that
-- fails part way still closes the wrapper, so neither ends the request in
-- an error. These load a broken copy of the script, so they come last.
h.load_with(script, { { "local function parse_man(text)", "local function parse_man(text) error('boom')" } })
out, ret = render("page.1", "<x>")
h.equals("a failed parse falls back to plain text", out, "<pre class='plaintext'>&lt;x&gt;</pre>")
h.equals("and close still answers zero", ret, 0)

h.load_with(script, { { "elseif kind == \"hr\" then", "elseif kind == \"hr\" then error('boom')" } })
out, ret = render("README.md", "# a\n\n---\n\nb")
h.equals("a failed emit still closes the wrapper", out, "<div class='markdown'><h1 id='a'>a</h1></div>")
h.equals("and close answers zero after it", ret, 0)

h.finish()