Use py.test to generate tests from the data files themselves.

Author: gsnedders

Diff for: .pytest.expect

@@ -0,0 +1,21 @@
+import os.path
+
+from .tree_construction import TreeConstructionFile
+
+_dir = os.path.abspath(os.path.dirname(__file__))
+_testdata = os.path.join(_dir, "testdata")
+_tree_construction = os.path.join(_testdata, "tree-construction")
+
+
+def pytest_collectstart():
+    """check to see if the git submodule has been init'd"""
+    pass
+
+
+def pytest_collect_file(path, parent):
+    dir = os.path.abspath(path.dirname)
+    if dir == _tree_construction:
+        if path.basename == "template.dat":
+            return
+        if path.ext == ".dat":
+            return TreeConstructionFile(path, parent)

Diff for: html5lib/tests/conftest.py

@@ -27,16 +27,18 @@
 try:
     import xml.etree.cElementTree as cElementTree
 except ImportError:
-    pass
+    treeTypes['cElementTree'] = None
 else:
     # On Python 3.3 and above cElementTree is an alias, don't run them twice.
-    if cElementTree.Element is not ElementTree.Element:
+    if cElementTree.Element is ElementTree.Element:
+        treeTypes['cElementTree'] = None
+    else:
         treeTypes['cElementTree'] = treebuilders.getTreeBuilder("etree", cElementTree, fullTree=True)
 
 try:
     import lxml.etree as lxml  # flake8: noqa
 except ImportError:
-    pass
+    treeTypes['lxml'] = None
 else:
     treeTypes['lxml'] = treebuilders.getTreeBuilder("lxml")
 
@@ -63,9 +65,6 @@ def __init__(self, filename, newTestHeading="data", encoding="utf8"):
         self.encoding = encoding
         self.newTestHeading = newTestHeading
 
-    def __del__(self):
-        self.f.close()
-
     def __iter__(self):
         data = DefaultDict(None)
         key = None

Diff for: html5lib/tests/support.py

@@ -0,0 +1,94 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import warnings
+import re
+
+import pytest
+
+from .support import TestData, convert, convertExpected, treeTypes
+from html5lib import html5parser, constants
+
+
+class TreeConstructionFile(pytest.File):
+    def collect(self):
+        tests = TestData(str(self.fspath), "data")
+        for i, test in enumerate(tests):
+            for treeName, treeClass in sorted(treeTypes.items()):
+                for namespaceHTMLElements in (True, False):
+                    if namespaceHTMLElements:
+                        nodeid = "%d::%s::namespaced" % (i, treeName)
+                    else:
+                        nodeid = "%d::%s::void-namespace" % (i, treeName)
+                    item = ParserTest(nodeid, self,
+                                      test, treeClass, namespaceHTMLElements)
+                    item.add_marker(getattr(pytest.mark, treeName))
+                    if namespaceHTMLElements:
+                        item.add_marker(pytest.mark.namespaced)
+                    if treeClass is None:
+                        item.add_marker(pytest.mark.skipif(True, reason="Treebuilder not loaded"))
+                    yield item
+
+
+def convertTreeDump(data):
+    return "\n".join(convert(3)(data).split("\n")[1:])
+
+namespaceExpected = re.compile(r"^(\s*)<(\S+)>", re.M).sub
+
+
+class ParserTest(pytest.Item):
+    def __init__(self, name, parent, test, treeClass, namespaceHTMLElements):
+        super(ParserTest, self).__init__(name, parent)
+        self.obj = lambda: 1  # this is to hack around skipif needing a function!
+        self.test = test
+        self.treeClass = treeClass
+        self.namespaceHTMLElements = namespaceHTMLElements
+
+    def runtest(self):
+        p = html5parser.HTMLParser(tree=self.treeClass,
+                                   namespaceHTMLElements=self.namespaceHTMLElements)
+
+        input = self.test['data']
+        fragmentContainer = self.test['document-fragment']
+        expected = self.test['document']
+        expectedErrors = self.test['errors'].split("\n") if self.test['errors'] else []
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            try:
+                if fragmentContainer:
+                    document = p.parseFragment(input, fragmentContainer)
+                else:
+                    document = p.parse(input)
+            except constants.DataLossWarning:
+                pytest.skip("data loss warning")
+
+        output = convertTreeDump(p.tree.testSerializer(document))
+
+        expected = convertExpected(expected)
+        if self.namespaceHTMLElements:
+            expected = namespaceExpected(r"\1<html \2>", expected)
+
+        errorMsg = "\n".join(["\n\nInput:", input, "\nExpected:", expected,
+                              "\nReceived:", output])
+        assert expected == output, errorMsg
+
+        errStr = []
+        for (line, col), errorcode, datavars in p.errors:
+            assert isinstance(datavars, dict), "%s, %s" % (errorcode, repr(datavars))
+            errStr.append("Line: %i Col: %i %s" % (line, col,
+                                                   constants.E[errorcode] % datavars))
+
+        errorMsg2 = "\n".join(["\n\nInput:", input,
+                               "\nExpected errors (" + str(len(expectedErrors)) + "):\n" + "\n".join(expectedErrors),
+                               "\nActual errors (" + str(len(p.errors)) + "):\n" + "\n".join(errStr)])
+        if False:  # we're currently not testing parse errors
+            assert len(p.errors) == len(expectedErrors), errorMsg2
+
+    def repr_failure(self, excinfo):
+        traceback = excinfo.traceback
+        ntraceback = traceback.cut(path=__file__)
+        excinfo.traceback = ntraceback.filter()
+
+        return excinfo.getrepr(funcargs=True,
+                               showlocals=False,
+                               style="short", tbfilter=False)

Diff for: html5lib/tests/test_parser.py

@@ -1,2 +1,2 @@
 [pytest]
-addopts = -rXw -p no:doctest
+addopts = -rXw -p no:doctest