diff options
Diffstat (limited to 'runtests.py')
| -rwxr-xr-x | runtests.py | 254 |
1 files changed, 254 insertions, 0 deletions
diff --git a/runtests.py b/runtests.py new file mode 100755 index 0000000..906a573 --- /dev/null +++ b/runtests.py @@ -0,0 +1,254 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +from ctypes import CDLL, c_char_p, c_long +import sys +import platform +from difflib import unified_diff +from subprocess import * +import argparse +from HTMLParser import HTMLParser +from htmlentitydefs import name2codepoint +import re + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Run cmark tests.') + parser.add_argument('--program', dest='program', nargs='?', default=None, + help='program to test') + parser.add_argument('--spec', dest='spec', nargs='?', default='spec.txt', + help='path to spec') + parser.add_argument('--pattern', dest='pattern', nargs='?', + default=None, help='limit to sections matching regex pattern') + parser.add_argument('--library_dir', dest='library_dir', nargs='?', + default=None, help='directory containing dynamic library') + args = parser.parse_args(sys.argv[1:]) + +if not args.program: + sysname = platform.system() + libname = "libcmark" + if sysname == 'Darwin': + libname += ".dylib" + elif sysname == 'Windows': + libname += ".dll" + else: + libname += ".so" + if args and args.library_dir: + libpath = args.library_dir + "/" + libname + else: + libpath = "build/src/" + libname + cmark = CDLL(libpath) + + markdown = cmark.cmark_markdown_to_html + markdown.restype = c_char_p + markdown.argtypes = [c_char_p, c_long] + +def md2html(text, prog): + if prog: + p1 = Popen([prog], stdout=PIPE, stdin=PIPE, stderr=PIPE) + [result, err] = p1.communicate(input=text) + return [p1.returncode, result, err] + else: + return [0, markdown(text, len(text)), ''] + +# Normalization code, adapted from +# https://github.com/karlcow/markdown-testsuite/ +significant_attrs = ["alt", "href", "src", "title"] +normalize_whitespace_re = re.compile('\s+') +class MyHTMLParser(HTMLParser): + def __init__(self): + HTMLParser.__init__(self) + self.last = "starttag" + self.in_pre = False + self.output = u"" + def handle_data(self, data): + if self.in_pre: + self.output += data + else: + data = normalize_whitespace_re.sub(' ', data) + data_strip = data.strip() + if (self.last == "ref") and data_strip and data[0] == " ": + self.output += " " + self.data_end_in_space_not_empty = (data[-1] == ' ' and data_strip) + self.output += data_strip + self.last = "data" + def handle_endtag(self, tag): + if tag == "pre": + self.in_pre = False + self.output += "</" + tag + ">" + self.last = "endtag" + def handle_starttag(self, tag, attrs): + if tag == "pre": + self.in_pre = True + self.output += "<" + tag + attrs = filter(lambda attr: attr[0] in significant_attrs, attrs) + if attrs: + attrs.sort() + for attr in attrs: + self.output += " " + attr[0] + "=" + '"' + attr[1] + '"' + self.output += ">" + self.last = "starttag" + def handle_startendtag(self, tag, attrs): + """Ignore closing tag for self-closing void elements.""" + self.handle_starttag(tag, attrs) + def handle_entityref(self, name): + self.add_space_from_last_data() + try: + self.output += unichr(name2codepoint[name]) + except KeyError: + self.output += name + self.last = "ref" + def handle_charref(self, name): + self.add_space_from_last_data() + try: + if name.startswith("x"): + c = unichr(int(name[1:], 16)) + else: + c = unichr(int(name)) + self.output += c + except ValueError: + self.output += name + self.last = "ref" + # Helpers. + def add_space_from_last_data(self): + """Maintain the space at: `a <span>b</span>`""" + if self.last == 'data' and self.data_end_in_space_not_empty: + self.output += ' ' + +def normalize(html): + r""" + Return normalized form of HTML which igores insignificant output differences. + Multiple inner whitespaces to a single space + >>> normalize("<p>a \t\nb</p>") + u'<p>a b</p>' + Surrounding whitespaces are removed: + >>> normalize("<p> a</p>") + u'<p>a</p>' + >>> normalize("<p>a </p>") + u'<p>a</p>' + TODO: how to deal with the following cases without a full list of the void tags? + >>> normalize("<p>a <b>b</b></p>") + u'<p>a<b>b</b></p>' + >>> normalize("<p><b>b</b> c</p>") + u'<p><b>b</b>c</p>' + >>> normalize("<p>a <br></p>") + u'<p>a<br></p>' + `pre` elements preserve whitespace: + >>> normalize("<pre>a \t\nb</pre>") + u'<pre>a \t\nb</pre>' + Self-closing tags: + >>> normalize("<p><br /></p>") + u'<p><br></p>' + References are converted to Unicode: + >>> normalize("<p><</p>") + u'<p><</p>' + >>> normalize("<p><</p>") + u'<p><</p>' + >>> normalize("<p><</p>") + u'<p><</p>' + >>> normalize("<p>中</p>") + u'<p>\u4e2d</p>' + Spaces around entities are kept: + >>> normalize("<p>a < b</p>") + u'<p>a < b</p>' + >>> normalize("<p>a<b</p>") + u'<p>a<b</p>' + Most attributes are ignored: + >>> normalize('<p id="a"></p>') + u'<p></p>' + Critical attributes are considered and sorted alphabetically: + >>> normalize('<a href="a"></a>') + u'<a href="a"></a>' + >>> normalize('<img src="a" alt="a">') + u'<img alt="a" src="a">' + """ + parser = MyHTMLParser() + parser.feed(html.decode(encoding='UTF-8')) + parser.close() + return parser.output + +def print_test_header(headertext, example_number, start_line, end_line): + print "Example %d (lines %d-%d) %s" % (example_number,start_line,end_line,headertext) + +def do_test(markdown_lines, expected_html_lines, headertext, + example_number, start_line, end_line, prog=None): + real_markdown_text = ''.join(markdown_lines).replace('→','\t') + [retcode, actual_html, err] = md2html(real_markdown_text, prog) + if retcode == 0: + actual_html_lines = actual_html.splitlines(True) + expected_html = ''.join(expected_html_lines) + if normalize(actual_html) == normalize(expected_html): + return 'pass' + else: + print_test_header(headertext, example_number,start_line,end_line) + sys.stdout.write(real_markdown_text) + for diffline in unified_diff(expected_html_lines, actual_html_lines, + "expected HTML", "actual HTML"): + sys.stdout.write(diffline) + sys.stdout.write('\n') + return 'fail' + else: + print_test_header(example_number,start_line,end_line) + print "program returned error code %d" % retcode + print(err) + return 'error' + +def do_tests(specfile, prog, pattern): + line_number = 0 + start_line = 0 + end_line = 0 + example_number = 0 + passed = 0 + failed = 0 + errored = 0 + markdown_lines = [] + html_lines = [] + active = True + state = 0 # 0 regular text, 1 markdown example, 2 html output + headertext = '' + + header_re = re.compile('#+ ') + if pattern: + pattern_re = re.compile(pattern) + + with open(specfile, 'r') as specf: + for line in specf: + line_number = line_number + 1 + if state == 0 and re.match(header_re, line): + headertext = header_re.sub('', line).strip() + if pattern: + if re.search(pattern_re, line): + active = True + else: + active = False + if line.strip() == ".": + state = (state + 1) % 3 + if state == 0: + example_number = example_number + 1 + end_line = line_number + if active: + result = do_test(markdown_lines, html_lines, + headertext, example_number, + start_line, end_line, prog) + if result == 'pass': + passed = passed + 1 + elif result == 'fail': + failed = failed + 1 + else: + errored = errored + 1 + start_line = 0 + markdown_lines = [] + html_lines = [] + elif state == 1: + if start_line == 0: + start_line = line_number + markdown_lines.append(line) + elif state == 2: + html_lines.append(line) + print "%d passed, %d failed, %d errored" % (passed, failed, errored) + return (failed == 0 and errored == 0) + +if __name__ == "__main__": + if do_tests(args.spec, args.program, args.pattern): + exit(0) + else: + exit(1) |