Port tests to use pytest

pytest is the preferred way to write and run unit tests these days and
it has a cleaner interface - so lets switch to it. The tokenizer tests
especially are much easier to read/understand.

This was mostly done with find/replace regexes and then cleaned up
manually.

.travis.yml

@@ -7,10 +7,10 @@ python:
     - 3.7
     - 3.8
 install:
-    - pip install coveralls
+    - pip install coveralls pytest
     - python setup.py develop
 script:
-    - coverage run --source=mwparserfromhell -m unittest discover
+    - coverage run --source=mwparserfromhell -m pytest
 after_success:
     - coveralls
 env:

appveyor.yml

@@ -64,14 +64,14 @@ environment:
 
 install:
   - "%PIP% install --disable-pip-version-check --user --upgrade pip"
-  - "%PIP% install wheel twine"
+  - "%PIP% install wheel twine pytest"
 
 build_script:
   - "%SETUPPY% build"
   - "%SETUPPY% develop --user"
 
 test_script:
-  - "%PYEXE% -m unittest discover"
+  - "%PYEXE% -m pytest"
 
 after_test:
   - "%SETUPPY% bdist_wheel"

setup.py

@@ -75,7 +75,7 @@ setup(
     name = "mwparserfromhell",
     packages = find_packages(exclude=("tests",)),
     ext_modules = [tokenizer] if use_extension else [],
-    test_suite = "tests",
+    test_requires = ["pytest"],
     version = __version__,
     python_requires = ">= 3.4",
     author = "Ben Kurtovic",

tests/_test_tokenizer.py

@@ -1,148 +0,0 @@
-#
-# Copyright (C) 2012-2016 Ben Kurtovic <ben.kurtovic@gmail.com>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-import codecs
-from os import listdir, path
-import sys
-import warnings
-
-from mwparserfromhell.parser import tokens
-from mwparserfromhell.parser.builder import Builder
-
-class _TestParseError(Exception):
-    """Raised internally when a test could not be parsed."""
-    pass
-
-
-class TokenizerTestCase:
-    """A base test case for tokenizers, whose tests are loaded dynamically.
-
-    Subclassed along with unittest.TestCase to form TestPyTokenizer and
-    TestCTokenizer. Tests are loaded dynamically from files in the 'tokenizer'
-    directory.
-    """
-
-    @staticmethod
-    def _build_test_method(funcname, data):
-        """Create and return a method to be treated as a test case method.
-
-        *data* is a dict containing multiple keys: the *input* text to be
-        tokenized, the expected list of tokens as *output*, and an optional
-        *label* for the method's docstring.
-        """
-        def inner(self):
-            if hasattr(self, "roundtrip"):
-                expected = data["input"]
-                actual = str(Builder().build(data["output"][:]))
-            else:
-                expected = data["output"]
-                actual = self.tokenizer().tokenize(data["input"])
-            self.assertEqual(expected, actual)
-
-        inner.__doc__ = data["label"]
-        return inner
-
-    @staticmethod
-    def _parse_test(test, data):
-        """Parse an individual *test*, storing its info in *data*."""
-        for line in test.strip().splitlines():
-            if line.startswith("name:"):
-                data["name"] = line[len("name:"):].strip()
-            elif line.startswith("label:"):
-                data["label"] = line[len("label:"):].strip()
-            elif line.startswith("input:"):
-                raw = line[len("input:"):].strip()
-                if raw[0] == '"' and raw[-1] == '"':
-                    raw = raw[1:-1]
-                raw = raw.encode("raw_unicode_escape")
-                data["input"] = raw.decode("unicode_escape")
-            elif line.startswith("output:"):
-                raw = line[len("output:"):].strip()
-                try:
-                    data["output"] = eval(raw, vars(tokens))
-                except Exception as err:
-                    raise _TestParseError(err)
-
-    @classmethod
-    def _load_tests(cls, filename, name, text, restrict=None):
-        """Load all tests in *text* from the file *filename*."""
-        tests = text.split("\n---\n")
-        counter = 1
-        digits = len(str(len(tests)))
-        for test in tests:
-            data = {"name": None, "label": None, "input": None, "output": None}
-            try:
-                cls._parse_test(test, data)
-            except _TestParseError as err:
-                if data["name"]:
-                    error = "Could not parse test '{0}' in '{1}':\n\t{2}"
-                    warnings.warn(error.format(data["name"], filename, err))
-                else:
-                    error = "Could not parse a test in '{0}':\n\t{1}"
-                    warnings.warn(error.format(filename, err))
-                continue
-
-            if not data["name"]:
-                error = "A test in '{0}' was ignored because it lacked a name"
-                warnings.warn(error.format(filename))
-                continue
-            if data["input"] is None or data["output"] is None:
-                error = "Test '{}' in '{}' was ignored because it lacked an input or an output"
-                warnings.warn(error.format(data["name"], filename))
-                continue
-
-            number = str(counter).zfill(digits)
-            counter += 1
-            if restrict and data["name"] != restrict:
-                continue
-
-            fname = "test_{}{}_{}".format(name, number, data["name"])
-            meth = cls._build_test_method(fname, data)
-            setattr(cls, fname, meth)
-
-    @classmethod
-    def build(cls):
-        """Load and install all tests from the 'tokenizer' directory."""
-        def load_file(filename, restrict=None):
-            with codecs.open(filename, "r", encoding="utf8") as fp:
-                text = fp.read()
-                name = path.split(filename)[1][:-len(extension)]
-                cls._load_tests(filename, name, text, restrict)
-
-        directory = path.join(path.dirname(__file__), "tokenizer")
-        extension = ".mwtest"
-        if len(sys.argv) > 2 and sys.argv[1] == "--use":
-            for name in sys.argv[2:]:
-                if "." in name:
-                    name, test = name.split(".", 1)
-                else:
-                    test = None
-                load_file(path.join(directory, name + extension), test)
-            sys.argv = [sys.argv[0]]  # So unittest doesn't try to parse this
-            cls.skip_others = True
-        else:
-            for filename in listdir(directory):
-                if not filename.endswith(extension):
-                    continue
-                load_file(path.join(directory, filename))
-            cls.skip_others = False
-
-TokenizerTestCase.build()

tests/_test_tree_equality.py

@@ -19,18 +19,16 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from unittest import TestCase
-
 from mwparserfromhell.nodes import (Argument, Comment, Heading, HTMLEntity,
                                     Tag, Template, Text, Wikilink)
-from mwparserfromhell.nodes.extras import Attribute, Parameter
 from mwparserfromhell.smart_list import SmartList
 from mwparserfromhell.wikicode import Wikicode
 
 wrap = lambda L: Wikicode(SmartList(L))
 wraptext = lambda *args: wrap([Text(t) for t in args])
 
-class TreeEqualityTestCase(TestCase):
+
+class TreeEqualityTestCase:
     """A base test case with support for comparing the equality of node trees.
 
     This adds a number of type equality functions, for Wikicode, Text,
@@ -51,7 +49,7 @@ class TreeEqualityTestCase(TestCase):
         }
         for nodetype in registry:
             if isinstance(expected, nodetype):
-                self.assertIsInstance(actual, nodetype)
+                assert isinstance(actual, nodetype)
                 registry[nodetype](expected, actual)
 
     def assertArgumentNodeEqual(self, expected, actual):
@@ -60,23 +58,23 @@ class TreeEqualityTestCase(TestCase):
         if expected.default is not None:
             self.assertWikicodeEqual(expected.default, actual.default)
         else:
-            self.assertIs(None, actual.default)
+            assert actual.default is None
 
     def assertCommentNodeEqual(self, expected, actual):
         """Assert that two Comment nodes have the same data."""
-        self.assertEqual(expected.contents, actual.contents)
+        assert expected.contents == actual.contents
 
     def assertHeadingNodeEqual(self, expected, actual):
         """Assert that two Heading nodes have the same data."""
         self.assertWikicodeEqual(expected.title, actual.title)
-        self.assertEqual(expected.level, actual.level)
+        assert expected.level == actual.level
 
     def assertHTMLEntityNodeEqual(self, expected, actual):
         """Assert that two HTMLEntity nodes have the same data."""
-        self.assertEqual(expected.value, actual.value)
-        self.assertIs(expected.named, actual.named)
-        self.assertIs(expected.hexadecimal, actual.hexadecimal)
-        self.assertEqual(expected.hex_char, actual.hex_char)
+        assert expected.value == actual.value
+        assert expected.named is actual.named
+        assert expected.hexadecimal is actual.hexadecimal
+        assert expected.hex_char == actual.hex_char
 
     def assertTagNodeEqual(self, expected, actual):
         """Assert that two Tag nodes have the same data."""
@@ -84,39 +82,39 @@ class TreeEqualityTestCase(TestCase):
         if expected.contents is not None:
             self.assertWikicodeEqual(expected.contents, actual.contents)
         length = len(expected.attributes)
-        self.assertEqual(length, len(actual.attributes))
+        assert length == len(actual.attributes)
         for i in range(length):
             exp_attr = expected.attributes[i]
             act_attr = actual.attributes[i]
             self.assertWikicodeEqual(exp_attr.name, act_attr.name)
             if exp_attr.value is not None:
                 self.assertWikicodeEqual(exp_attr.value, act_attr.value)
-                self.assertEqual(exp_attr.quotes, act_attr.quotes)
-            self.assertEqual(exp_attr.pad_first, act_attr.pad_first)
-            self.assertEqual(exp_attr.pad_before_eq, act_attr.pad_before_eq)
-            self.assertEqual(exp_attr.pad_after_eq, act_attr.pad_after_eq)
-        self.assertEqual(expected.wiki_markup, actual.wiki_markup)
-        self.assertIs(expected.self_closing, actual.self_closing)
-        self.assertIs(expected.invalid, actual.invalid)
-        self.assertIs(expected.implicit, actual.implicit)
-        self.assertEqual(expected.padding, actual.padding)
+                assert exp_attr.quotes == act_attr.quotes
+            assert exp_attr.pad_first == act_attr.pad_first
+            assert exp_attr.pad_before_eq == act_attr.pad_before_eq
+            assert exp_attr.pad_after_eq == act_attr.pad_after_eq
+        assert expected.wiki_markup == actual.wiki_markup
+        assert expected.self_closing is actual.self_closing
+        assert expected.invalid is actual.invalid
+        assert expected.implicit is actual.implicit
+        assert expected.padding == actual.padding
         self.assertWikicodeEqual(expected.closing_tag, actual.closing_tag)
 
     def assertTemplateNodeEqual(self, expected, actual):
         """Assert that two Template nodes have the same data."""
         self.assertWikicodeEqual(expected.name, actual.name)
         length = len(expected.params)
-        self.assertEqual(length, len(actual.params))
+        assert length == len(actual.params)
         for i in range(length):
             exp_param = expected.params[i]
             act_param = actual.params[i]
             self.assertWikicodeEqual(exp_param.name, act_param.name)
             self.assertWikicodeEqual(exp_param.value, act_param.value)
-            self.assertIs(exp_param.showkey, act_param.showkey)
+            assert exp_param.showkey is act_param.showkey
 
     def assertTextNodeEqual(self, expected, actual):
         """Assert that two Text nodes have the same data."""
-        self.assertEqual(expected.value, actual.value)
+        assert expected.value == actual.value
 
     def assertWikilinkNodeEqual(self, expected, actual):
         """Assert that two Wikilink nodes have the same data."""
@@ -124,12 +122,12 @@ class TreeEqualityTestCase(TestCase):
         if expected.text is not None:
             self.assertWikicodeEqual(expected.text, actual.text)
         else:
-            self.assertIs(None, actual.text)
+            assert None is actual.text
 
     def assertWikicodeEqual(self, expected, actual):
         """Assert that two Wikicode objects have the same data."""
-        self.assertIsInstance(actual, Wikicode)
+        assert isinstance(actual, Wikicode)
         length = len(expected.nodes)
-        self.assertEqual(length, len(actual.nodes))
+        assert length == len(actual.nodes)
         for i in range(length):
             self.assertNodeEqual(expected.get(i), actual.get(i))

tests/test_argument.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import Argument, Text
 
@@ -31,9 +31,9 @@ class TestArgument(TreeEqualityTestCase):
     def test_unicode(self):
         """test Argument.__unicode__()"""
         node = Argument(wraptext("foobar"))
-        self.assertEqual("{{{foobar}}}", str(node))
+        assert "{{{foobar}}}" == str(node)
         node2 = Argument(wraptext("foo"), wraptext("bar"))
-        self.assertEqual("{{{foo|bar}}}", str(node2))
+        assert "{{{foo|bar}}}" == str(node2)
 
     def test_children(self):
         """test Argument.__children__()"""
@@ -41,18 +41,20 @@ class TestArgument(TreeEqualityTestCase):
         node2 = Argument(wraptext("foo"), wrap([Text("bar"), Text("baz")]))
         gen1 = node1.__children__()
         gen2 = node2.__children__()
-        self.assertIs(node1.name, next(gen1))
-        self.assertIs(node2.name, next(gen2))
-        self.assertIs(node2.default, next(gen2))
-        self.assertRaises(StopIteration, next, gen1)
-        self.assertRaises(StopIteration, next, gen2)
+        assert node1.name is next(gen1)
+        assert node2.name is next(gen2)
+        assert node2.default is next(gen2)
+        with pytest.raises(StopIteration):
+            next(gen1)
+        with pytest.raises(StopIteration):
+            next(gen2)
 
     def test_strip(self):
         """test Argument.__strip__()"""
         node1 = Argument(wraptext("foobar"))
         node2 = Argument(wraptext("foo"), wraptext("bar"))
-        self.assertIs(None, node1.__strip__())
-        self.assertEqual("bar", node2.__strip__())
+        assert node1.__strip__() is None
+        assert "bar" == node2.__strip__()
 
     def test_showtree(self):
         """test Argument.__showtree__()"""
@@ -67,15 +69,15 @@ class TestArgument(TreeEqualityTestCase):
         valid = [
             "{{{", (getter, node1.name), "}}}", "{{{", (getter, node2.name),
             "    | ", marker, (getter, node2.default), "}}}"]
-        self.assertEqual(valid, output)
+        assert valid == output
 
     def test_name(self):
         """test getter/setter for the name attribute"""
         name = wraptext("foobar")
         node1 = Argument(name)
         node2 = Argument(name, wraptext("baz"))
-        self.assertIs(name, node1.name)
-        self.assertIs(name, node2.name)
+        assert name is node1.name
+        assert name is node2.name
         node1.name = "héhehé"
         node2.name = "héhehé"
         self.assertWikicodeEqual(wraptext("héhehé"), node1.name)
@@ -86,12 +88,9 @@ class TestArgument(TreeEqualityTestCase):
         default = wraptext("baz")
         node1 = Argument(wraptext("foobar"))
         node2 = Argument(wraptext("foobar"), default)
-        self.assertIs(None, node1.default)
-        self.assertIs(default, node2.default)
+        assert None is node1.default
+        assert default is node2.default
         node1.default = "buzz"
         node2.default = None
         self.assertWikicodeEqual(wraptext("buzz"), node1.default)
-        self.assertIs(None, node2.default)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert None is node2.default

tests/test_attribute.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import Template
 from mwparserfromhell.nodes.extras import Attribute
@@ -32,23 +32,23 @@ class TestAttribute(TreeEqualityTestCase):
     def test_unicode(self):
         """test Attribute.__unicode__()"""
         node = Attribute(wraptext("foo"))
-        self.assertEqual(" foo", str(node))
+        assert " foo" == str(node)
         node2 = Attribute(wraptext("foo"), wraptext("bar"))
-        self.assertEqual(' foo="bar"', str(node2))
+        assert ' foo="bar"' == str(node2)
         node3 = Attribute(wraptext("a"), wraptext("b"), '"', "", " ", "   ")
-        self.assertEqual('a =   "b"', str(node3))
+        assert 'a =   "b"' == str(node3)
         node4 = Attribute(wraptext("a"), wraptext("b"), "'", "", " ", "   ")
-        self.assertEqual("a =   'b'", str(node4))
+        assert "a =   'b'" == str(node4)
         node5 = Attribute(wraptext("a"), wraptext("b"), None, "", " ", "   ")
-        self.assertEqual("a =   b", str(node5))
+        assert "a =   b" == str(node5)
         node6 = Attribute(wraptext("a"), wrap([]), None, " ", "", " ")
-        self.assertEqual(" a= ", str(node6))
+        assert " a= " == str(node6)
 
     def test_name(self):
         """test getter/setter for the name attribute"""
         name = wraptext("id")
         node = Attribute(name, wraptext("bar"))
-        self.assertIs(name, node.name)
+        assert name is node.name
         node.name = "{{id}}"
         self.assertWikicodeEqual(wrap([Template(wraptext("id"))]), node.name)
 
@@ -56,51 +56,51 @@ class TestAttribute(TreeEqualityTestCase):
         """test getter/setter for the value attribute"""
         value = wraptext("foo")
         node = Attribute(wraptext("id"), value)
-        self.assertIs(value, node.value)
+        assert value is node.value
         node.value = "{{bar}}"
         self.assertWikicodeEqual(wrap([Template(wraptext("bar"))]), node.value)
         node.value = None
-        self.assertIs(None, node.value)
+        assert None is node.value
         node2 = Attribute(wraptext("id"), wraptext("foo"), None)
         node2.value = "foo bar baz"
         self.assertWikicodeEqual(wraptext("foo bar baz"), node2.value)
-        self.assertEqual('"', node2.quotes)
+        assert '"' == node2.quotes
         node2.value = 'foo "bar" baz'
         self.assertWikicodeEqual(wraptext('foo "bar" baz'), node2.value)
-        self.assertEqual("'", node2.quotes)
+        assert "'" == node2.quotes
         node2.value = "foo 'bar' baz"
         self.assertWikicodeEqual(wraptext("foo 'bar' baz"), node2.value)
-        self.assertEqual('"', node2.quotes)
+        assert '"' == node2.quotes
         node2.value = "fo\"o 'bar' b\"az"
         self.assertWikicodeEqual(wraptext("fo\"o 'bar' b\"az"), node2.value)
-        self.assertEqual('"', node2.quotes)
+        assert '"' == node2.quotes
 
     def test_quotes(self):
         """test getter/setter for the quotes attribute"""
         node1 = Attribute(wraptext("id"), wraptext("foo"), None)
         node2 = Attribute(wraptext("id"), wraptext("bar"))
         node3 = Attribute(wraptext("id"), wraptext("foo bar baz"))
-        self.assertIs(None, node1.quotes)
-        self.assertEqual('"', node2.quotes)
+        assert None is node1.quotes
+        assert '"' == node2.quotes
         node1.quotes = "'"
         node2.quotes = None
-        self.assertEqual("'", node1.quotes)
-        self.assertIs(None, node2.quotes)
-        self.assertRaises(ValueError, setattr, node1, "quotes", "foobar")
-        self.assertRaises(ValueError, setattr, node3, "quotes", None)
-        self.assertRaises(ValueError, Attribute, wraptext("id"),
-                          wraptext("foo bar baz"), None)
+        assert "'" == node1.quotes
+        assert None is node2.quotes
+        with pytest.raises(ValueError):
+            node1.__setattr__("quotes", "foobar")
+        with pytest.raises(ValueError):
+            node3.__setattr__("quotes", None)
+        with pytest.raises(ValueError):
+            Attribute(wraptext("id"), wraptext("foo bar baz"), None)
 
     def test_padding(self):
         """test getter/setter for the padding attributes"""
         for pad in ["pad_first", "pad_before_eq", "pad_after_eq"]:
             node = Attribute(wraptext("id"), wraptext("foo"), **{pad: "\n"})
-            self.assertEqual("\n", getattr(node, pad))
+            assert "\n" == getattr(node, pad)
             setattr(node, pad, " ")
-            self.assertEqual(" ", getattr(node, pad))
+            assert " " == getattr(node, pad)
             setattr(node, pad, None)
-            self.assertEqual("", getattr(node, pad))
-            self.assertRaises(ValueError, setattr, node, pad, True)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+            assert "" == getattr(node, pad)
+            with pytest.raises(ValueError):
+                node.__setattr__(pad, True)

tests/test_builder.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import (Argument, Comment, ExternalLink, Heading,
                                     HTMLEntity, Tag, Template, Text, Wikilink)
@@ -32,336 +32,328 @@ from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext
 class TestBuilder(TreeEqualityTestCase):
     """Tests for the builder, which turns tokens into Wikicode objects."""
 
-    def setUp(self):
-        self.builder = Builder()
-
-    def test_text(self):
+    @pytest.fixture()
+    def builder(self):
+        return Builder()
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.Text(text="foobar")], wraptext("foobar")),
+        ([tokens.Text(text="fóóbar")], wraptext("fóóbar")),
+        ([tokens.Text(text="spam"), tokens.Text(text="eggs")],
+         wraptext("spam", "eggs")),
+    ])
+    def test_text(self, builder, test, valid):
         """tests for building Text nodes"""
-        tests = [
-            ([tokens.Text(text="foobar")], wraptext("foobar")),
-            ([tokens.Text(text="fóóbar")], wraptext("fóóbar")),
-            ([tokens.Text(text="spam"), tokens.Text(text="eggs")],
-             wraptext("spam", "eggs")),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_template(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.TemplateOpen(), tokens.Text(text="foobar"),
+          tokens.TemplateClose()],
+         wrap([Template(wraptext("foobar"))])),
+
+        ([tokens.TemplateOpen(), tokens.Text(text="spam"),
+          tokens.Text(text="eggs"), tokens.TemplateClose()],
+         wrap([Template(wraptext("spam", "eggs"))])),
+
+        ([tokens.TemplateOpen(), tokens.Text(text="foo"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="bar"),
+          tokens.TemplateClose()],
+         wrap([Template(wraptext("foo"), params=[
+             Parameter(wraptext("1"), wraptext("bar"), showkey=False)])])),
+
+        ([tokens.TemplateOpen(), tokens.Text(text="foo"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="bar"),
+          tokens.TemplateParamEquals(), tokens.Text(text="baz"),
+          tokens.TemplateClose()],
+         wrap([Template(wraptext("foo"), params=[
+             Parameter(wraptext("bar"), wraptext("baz"))])])),
+
+        ([tokens.TemplateOpen(), tokens.TemplateParamSeparator(),
+          tokens.TemplateParamSeparator(), tokens.TemplateParamEquals(),
+          tokens.TemplateParamSeparator(), tokens.TemplateClose()],
+         wrap([Template(wrap([]), params=[
+             Parameter(wraptext("1"), wrap([]), showkey=False),
+             Parameter(wrap([]), wrap([]), showkey=True),
+             Parameter(wraptext("2"), wrap([]), showkey=False)])])),
+
+        ([tokens.TemplateOpen(), tokens.Text(text="foo"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="bar"),
+          tokens.TemplateParamEquals(), tokens.Text(text="baz"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="biz"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="buzz"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="3"),
+          tokens.TemplateParamEquals(), tokens.Text(text="buff"),
+          tokens.TemplateParamSeparator(), tokens.Text(text="baff"),
+          tokens.TemplateClose()],
+         wrap([Template(wraptext("foo"), params=[
+             Parameter(wraptext("bar"), wraptext("baz")),
+             Parameter(wraptext("1"), wraptext("biz"), showkey=False),
+             Parameter(wraptext("2"), wraptext("buzz"), showkey=False),
+             Parameter(wraptext("3"), wraptext("buff")),
+             Parameter(wraptext("3"), wraptext("baff"),
+                       showkey=False)])])),
+    ])
+    def test_template(self, builder, test, valid):
         """tests for building Template nodes"""
-        tests = [
-            ([tokens.TemplateOpen(), tokens.Text(text="foobar"),
-              tokens.TemplateClose()],
-             wrap([Template(wraptext("foobar"))])),
-
-            ([tokens.TemplateOpen(), tokens.Text(text="spam"),
-              tokens.Text(text="eggs"), tokens.TemplateClose()],
-             wrap([Template(wraptext("spam", "eggs"))])),
-
-            ([tokens.TemplateOpen(), tokens.Text(text="foo"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="bar"),
-              tokens.TemplateClose()],
-             wrap([Template(wraptext("foo"), params=[
-                 Parameter(wraptext("1"), wraptext("bar"), showkey=False)])])),
-
-            ([tokens.TemplateOpen(), tokens.Text(text="foo"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="bar"),
-              tokens.TemplateParamEquals(), tokens.Text(text="baz"),
-              tokens.TemplateClose()],
-             wrap([Template(wraptext("foo"), params=[
-                 Parameter(wraptext("bar"), wraptext("baz"))])])),
-
-            ([tokens.TemplateOpen(), tokens.TemplateParamSeparator(),
-              tokens.TemplateParamSeparator(), tokens.TemplateParamEquals(),
-              tokens.TemplateParamSeparator(), tokens.TemplateClose()],
-             wrap([Template(wrap([]), params=[
-                 Parameter(wraptext("1"), wrap([]), showkey=False),
-                 Parameter(wrap([]), wrap([]), showkey=True),
-                 Parameter(wraptext("2"), wrap([]), showkey=False)])])),
-
-            ([tokens.TemplateOpen(), tokens.Text(text="foo"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="bar"),
-              tokens.TemplateParamEquals(), tokens.Text(text="baz"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="biz"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="buzz"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="3"),
-              tokens.TemplateParamEquals(), tokens.Text(text="buff"),
-              tokens.TemplateParamSeparator(), tokens.Text(text="baff"),
-              tokens.TemplateClose()],
-             wrap([Template(wraptext("foo"), params=[
-                 Parameter(wraptext("bar"), wraptext("baz")),
-                 Parameter(wraptext("1"), wraptext("biz"), showkey=False),
-                 Parameter(wraptext("2"), wraptext("buzz"), showkey=False),
-                 Parameter(wraptext("3"), wraptext("buff")),
-                 Parameter(wraptext("3"), wraptext("baff"),
-                           showkey=False)])])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_argument(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.ArgumentOpen(), tokens.Text(text="foobar"),
+          tokens.ArgumentClose()],
+         wrap([Argument(wraptext("foobar"))])),
+
+        ([tokens.ArgumentOpen(), tokens.Text(text="spam"),
+          tokens.Text(text="eggs"), tokens.ArgumentClose()],
+         wrap([Argument(wraptext("spam", "eggs"))])),
+
+        ([tokens.ArgumentOpen(), tokens.Text(text="foo"),
+          tokens.ArgumentSeparator(), tokens.Text(text="bar"),
+          tokens.ArgumentClose()],
+         wrap([Argument(wraptext("foo"), wraptext("bar"))])),
+
+        ([tokens.ArgumentOpen(), tokens.Text(text="foo"),
+          tokens.Text(text="bar"), tokens.ArgumentSeparator(),
+          tokens.Text(text="baz"), tokens.Text(text="biz"),
+          tokens.ArgumentClose()],
+         wrap([Argument(wraptext("foo", "bar"), wraptext("baz", "biz"))])),
+    ])
+    def test_argument(self, builder, test, valid):
         """tests for building Argument nodes"""
-        tests = [
-            ([tokens.ArgumentOpen(), tokens.Text(text="foobar"),
-              tokens.ArgumentClose()],
-             wrap([Argument(wraptext("foobar"))])),
-
-            ([tokens.ArgumentOpen(), tokens.Text(text="spam"),
-              tokens.Text(text="eggs"), tokens.ArgumentClose()],
-             wrap([Argument(wraptext("spam", "eggs"))])),
-
-            ([tokens.ArgumentOpen(), tokens.Text(text="foo"),
-              tokens.ArgumentSeparator(), tokens.Text(text="bar"),
-              tokens.ArgumentClose()],
-             wrap([Argument(wraptext("foo"), wraptext("bar"))])),
-
-            ([tokens.ArgumentOpen(), tokens.Text(text="foo"),
-              tokens.Text(text="bar"), tokens.ArgumentSeparator(),
-              tokens.Text(text="baz"), tokens.Text(text="biz"),
-              tokens.ArgumentClose()],
-             wrap([Argument(wraptext("foo", "bar"), wraptext("baz", "biz"))])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_wikilink(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.WikilinkOpen(), tokens.Text(text="foobar"),
+          tokens.WikilinkClose()],
+         wrap([Wikilink(wraptext("foobar"))])),
+
+        ([tokens.WikilinkOpen(), tokens.Text(text="spam"),
+          tokens.Text(text="eggs"), tokens.WikilinkClose()],
+         wrap([Wikilink(wraptext("spam", "eggs"))])),
+
+        ([tokens.WikilinkOpen(), tokens.Text(text="foo"),
+          tokens.WikilinkSeparator(), tokens.Text(text="bar"),
+          tokens.WikilinkClose()],
+         wrap([Wikilink(wraptext("foo"), wraptext("bar"))])),
+
+        ([tokens.WikilinkOpen(), tokens.Text(text="foo"),
+          tokens.Text(text="bar"), tokens.WikilinkSeparator(),
+          tokens.Text(text="baz"), tokens.Text(text="biz"),
+          tokens.WikilinkClose()],
+         wrap([Wikilink(wraptext("foo", "bar"), wraptext("baz", "biz"))])),
+    ])
+    def test_wikilink(self, builder, test, valid):
         """tests for building Wikilink nodes"""
-        tests = [
-            ([tokens.WikilinkOpen(), tokens.Text(text="foobar"),
-              tokens.WikilinkClose()],
-             wrap([Wikilink(wraptext("foobar"))])),
-
-            ([tokens.WikilinkOpen(), tokens.Text(text="spam"),
-              tokens.Text(text="eggs"), tokens.WikilinkClose()],
-             wrap([Wikilink(wraptext("spam", "eggs"))])),
-
-            ([tokens.WikilinkOpen(), tokens.Text(text="foo"),
-              tokens.WikilinkSeparator(), tokens.Text(text="bar"),
-              tokens.WikilinkClose()],
-             wrap([Wikilink(wraptext("foo"), wraptext("bar"))])),
-
-            ([tokens.WikilinkOpen(), tokens.Text(text="foo"),
-              tokens.Text(text="bar"), tokens.WikilinkSeparator(),
-              tokens.Text(text="baz"), tokens.Text(text="biz"),
-              tokens.WikilinkClose()],
-             wrap([Wikilink(wraptext("foo", "bar"), wraptext("baz", "biz"))])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_external_link(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.ExternalLinkOpen(brackets=False),
+          tokens.Text(text="http://example.com/"),
+          tokens.ExternalLinkClose()],
+         wrap([ExternalLink(wraptext("http://example.com/"),
+                            brackets=False)])),
+
+        ([tokens.ExternalLinkOpen(brackets=True),
+          tokens.Text(text="http://example.com/"),
+          tokens.ExternalLinkClose()],
+         wrap([ExternalLink(wraptext("http://example.com/"))])),
+
+        ([tokens.ExternalLinkOpen(brackets=True),
+          tokens.Text(text="http://example.com/"),
+          tokens.ExternalLinkSeparator(), tokens.ExternalLinkClose()],
+         wrap([ExternalLink(wraptext("http://example.com/"), wrap([]))])),
+
+        ([tokens.ExternalLinkOpen(brackets=True),
+          tokens.Text(text="http://example.com/"),
+          tokens.ExternalLinkSeparator(), tokens.Text(text="Example"),
+          tokens.ExternalLinkClose()],
+         wrap([ExternalLink(wraptext("http://example.com/"),
+                            wraptext("Example"))])),
+
+        ([tokens.ExternalLinkOpen(brackets=False),
+          tokens.Text(text="http://example"), tokens.Text(text=".com/foo"),
+          tokens.ExternalLinkClose()],
+         wrap([ExternalLink(wraptext("http://example", ".com/foo"),
+                            brackets=False)])),
+
+        ([tokens.ExternalLinkOpen(brackets=True),
+          tokens.Text(text="http://example"), tokens.Text(text=".com/foo"),
+          tokens.ExternalLinkSeparator(), tokens.Text(text="Example"),
+          tokens.Text(text=" Web Page"), tokens.ExternalLinkClose()],
+         wrap([ExternalLink(wraptext("http://example", ".com/foo"),
+                            wraptext("Example", " Web Page"))])),
+    ])
+    def test_external_link(self, builder, test, valid):
         """tests for building ExternalLink nodes"""
-        tests = [
-            ([tokens.ExternalLinkOpen(brackets=False),
-              tokens.Text(text="http://example.com/"),
-              tokens.ExternalLinkClose()],
-             wrap([ExternalLink(wraptext("http://example.com/"),
-                                brackets=False)])),
-
-            ([tokens.ExternalLinkOpen(brackets=True),
-              tokens.Text(text="http://example.com/"),
-              tokens.ExternalLinkClose()],
-             wrap([ExternalLink(wraptext("http://example.com/"))])),
-
-            ([tokens.ExternalLinkOpen(brackets=True),
-              tokens.Text(text="http://example.com/"),
-              tokens.ExternalLinkSeparator(), tokens.ExternalLinkClose()],
-             wrap([ExternalLink(wraptext("http://example.com/"), wrap([]))])),
-
-            ([tokens.ExternalLinkOpen(brackets=True),
-              tokens.Text(text="http://example.com/"),
-              tokens.ExternalLinkSeparator(), tokens.Text(text="Example"),
-              tokens.ExternalLinkClose()],
-             wrap([ExternalLink(wraptext("http://example.com/"),
-                                wraptext("Example"))])),
-
-            ([tokens.ExternalLinkOpen(brackets=False),
-              tokens.Text(text="http://example"), tokens.Text(text=".com/foo"),
-              tokens.ExternalLinkClose()],
-             wrap([ExternalLink(wraptext("http://example", ".com/foo"),
-                                brackets=False)])),
-
-            ([tokens.ExternalLinkOpen(brackets=True),
-              tokens.Text(text="http://example"), tokens.Text(text=".com/foo"),
-              tokens.ExternalLinkSeparator(), tokens.Text(text="Example"),
-              tokens.Text(text=" Web Page"), tokens.ExternalLinkClose()],
-             wrap([ExternalLink(wraptext("http://example", ".com/foo"),
-                                wraptext("Example", " Web Page"))])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_html_entity(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.HTMLEntityStart(), tokens.Text(text="nbsp"),
+          tokens.HTMLEntityEnd()],
+         wrap([HTMLEntity("nbsp", named=True, hexadecimal=False)])),
+
+        ([tokens.HTMLEntityStart(), tokens.HTMLEntityNumeric(),
+          tokens.Text(text="107"), tokens.HTMLEntityEnd()],
+         wrap([HTMLEntity("107", named=False, hexadecimal=False)])),
+
+        ([tokens.HTMLEntityStart(), tokens.HTMLEntityNumeric(),
+          tokens.HTMLEntityHex(char="X"), tokens.Text(text="6B"),
+          tokens.HTMLEntityEnd()],
+         wrap([HTMLEntity("6B", named=False, hexadecimal=True,
+                          hex_char="X")])),
+    ])
+    def test_html_entity(self, builder, test, valid):
         """tests for building HTMLEntity nodes"""
-        tests = [
-            ([tokens.HTMLEntityStart(), tokens.Text(text="nbsp"),
-              tokens.HTMLEntityEnd()],
-             wrap([HTMLEntity("nbsp", named=True, hexadecimal=False)])),
-
-            ([tokens.HTMLEntityStart(), tokens.HTMLEntityNumeric(),
-              tokens.Text(text="107"), tokens.HTMLEntityEnd()],
-             wrap([HTMLEntity("107", named=False, hexadecimal=False)])),
-
-            ([tokens.HTMLEntityStart(), tokens.HTMLEntityNumeric(),
-              tokens.HTMLEntityHex(char="X"), tokens.Text(text="6B"),
-              tokens.HTMLEntityEnd()],
-             wrap([HTMLEntity("6B", named=False, hexadecimal=True,
-                              hex_char="X")])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_heading(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.HeadingStart(level=2), tokens.Text(text="foobar"),
+          tokens.HeadingEnd()],
+         wrap([Heading(wraptext("foobar"), 2)])),
+
+        ([tokens.HeadingStart(level=4), tokens.Text(text="spam"),
+          tokens.Text(text="eggs"), tokens.HeadingEnd()],
+         wrap([Heading(wraptext("spam", "eggs"), 4)])),
+    ])
+    def test_heading(self, builder, test, valid):
         """tests for building Heading nodes"""
-        tests = [
-            ([tokens.HeadingStart(level=2), tokens.Text(text="foobar"),
-              tokens.HeadingEnd()],
-             wrap([Heading(wraptext("foobar"), 2)])),
-
-            ([tokens.HeadingStart(level=4), tokens.Text(text="spam"),
-              tokens.Text(text="eggs"), tokens.HeadingEnd()],
-             wrap([Heading(wraptext("spam", "eggs"), 4)])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_comment(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        ([tokens.CommentStart(), tokens.Text(text="foobar"),
+          tokens.CommentEnd()],
+         wrap([Comment("foobar")])),
+
+        ([tokens.CommentStart(), tokens.Text(text="spam"),
+          tokens.Text(text="eggs"), tokens.CommentEnd()],
+         wrap([Comment("spameggs")])),
+    ])
+    def test_comment(self, builder, test, valid):
         """tests for building Comment nodes"""
-        tests = [
-            ([tokens.CommentStart(), tokens.Text(text="foobar"),
-              tokens.CommentEnd()],
-             wrap([Comment("foobar")])),
-
-            ([tokens.CommentStart(), tokens.Text(text="spam"),
-              tokens.Text(text="eggs"), tokens.CommentEnd()],
-             wrap([Comment("spameggs")])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_tag(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("test,valid", [
+        # <ref></ref>
+        ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
+          tokens.TagCloseOpen(padding=""), tokens.TagOpenClose(),
+          tokens.Text(text="ref"), tokens.TagCloseClose()],
+         wrap([Tag(wraptext("ref"), wrap([]),
+                   closing_tag=wraptext("ref"))])),
+
+        # <ref name></ref>
+        ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
+          tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
+                              pad_after_eq=""),
+          tokens.Text(text="name"), tokens.TagCloseOpen(padding=""),
+          tokens.TagOpenClose(), tokens.Text(text="ref"),
+          tokens.TagCloseClose()],
+         wrap([Tag(wraptext("ref"), wrap([]),
+                  attrs=[Attribute(wraptext("name"))])])),
+
+        # <ref name="abc" />
+        ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
+          tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
+                              pad_after_eq=""),
+          tokens.Text(text="name"), tokens.TagAttrEquals(),
+          tokens.TagAttrQuote(char='"'), tokens.Text(text="abc"),
+          tokens.TagCloseSelfclose(padding=" ")],
+         wrap([Tag(wraptext("ref"),
+                   attrs=[Attribute(wraptext("name"), wraptext("abc"))],
+                   self_closing=True, padding=" ")])),
+
+        # <br/>
+        ([tokens.TagOpenOpen(), tokens.Text(text="br"),
+          tokens.TagCloseSelfclose(padding="")],
+         wrap([Tag(wraptext("br"), self_closing=True)])),
+
+        # <li>
+        ([tokens.TagOpenOpen(), tokens.Text(text="li"),
+          tokens.TagCloseSelfclose(padding="", implicit=True)],
+         wrap([Tag(wraptext("li"), self_closing=True, implicit=True)])),
+
+        # </br>
+        ([tokens.TagOpenOpen(invalid=True), tokens.Text(text="br"),
+          tokens.TagCloseSelfclose(padding="", implicit=True)],
+         wrap([Tag(wraptext("br"), self_closing=True, invalid=True,
+                   implicit=True)])),
+
+        # </br/>
+        ([tokens.TagOpenOpen(invalid=True), tokens.Text(text="br"),
+          tokens.TagCloseSelfclose(padding="")],
+         wrap([Tag(wraptext("br"), self_closing=True, invalid=True)])),
+
+        # <ref name={{abc}}   foo="bar {{baz}}" abc={{de}}f ghi=j{{k}}{{l}}
+        #      mno =  '{{p}} [[q]] {{r}}'>[[Source]]</ref>
+        ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
+          tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
+                              pad_after_eq=""),
+          tokens.Text(text="name"), tokens.TagAttrEquals(),
+          tokens.TemplateOpen(), tokens.Text(text="abc"),
+          tokens.TemplateClose(),
+          tokens.TagAttrStart(pad_first="   ", pad_before_eq="",
+                              pad_after_eq=""),
+          tokens.Text(text="foo"), tokens.TagAttrEquals(),
+          tokens.TagAttrQuote(char='"'), tokens.Text(text="bar "),
+          tokens.TemplateOpen(), tokens.Text(text="baz"),
+          tokens.TemplateClose(),
+          tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
+                              pad_after_eq=""),
+          tokens.Text(text="abc"), tokens.TagAttrEquals(),
+          tokens.TemplateOpen(), tokens.Text(text="de"),
+          tokens.TemplateClose(), tokens.Text(text="f"),
+          tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
+                              pad_after_eq=""),
+          tokens.Text(text="ghi"), tokens.TagAttrEquals(),
+          tokens.Text(text="j"), tokens.TemplateOpen(),
+          tokens.Text(text="k"), tokens.TemplateClose(),
+          tokens.TemplateOpen(), tokens.Text(text="l"),
+          tokens.TemplateClose(),
+          tokens.TagAttrStart(pad_first=" \n ", pad_before_eq=" ",
+                              pad_after_eq="  "),
+          tokens.Text(text="mno"), tokens.TagAttrEquals(),
+          tokens.TagAttrQuote(char="'"), tokens.TemplateOpen(),
+          tokens.Text(text="p"), tokens.TemplateClose(),
+          tokens.Text(text=" "), tokens.WikilinkOpen(),
+          tokens.Text(text="q"), tokens.WikilinkClose(),
+          tokens.Text(text=" "), tokens.TemplateOpen(),
+          tokens.Text(text="r"), tokens.TemplateClose(),
+          tokens.TagCloseOpen(padding=""), tokens.WikilinkOpen(),
+          tokens.Text(text="Source"), tokens.WikilinkClose(),
+          tokens.TagOpenClose(), tokens.Text(text="ref"),
+          tokens.TagCloseClose()],
+         wrap([Tag(wraptext("ref"), wrap([Wikilink(wraptext("Source"))]), [
+                Attribute(wraptext("name"),
+                          wrap([Template(wraptext("abc"))]), None),
+                Attribute(wraptext("foo"), wrap([Text("bar "),
+                          Template(wraptext("baz"))]), pad_first="   "),
+                Attribute(wraptext("abc"), wrap([Template(wraptext("de")),
+                          Text("f")]), None),
+                Attribute(wraptext("ghi"), wrap([Text("j"),
+                          Template(wraptext("k")),
+                          Template(wraptext("l"))]), None),
+                Attribute(wraptext("mno"), wrap([Template(wraptext("p")),
+                          Text(" "), Wikilink(wraptext("q")), Text(" "),
+                          Template(wraptext("r"))]), "'", " \n ", " ",
+                          "  ")])])),
+
+        # "''italic text''"
+        ([tokens.TagOpenOpen(wiki_markup="''"), tokens.Text(text="i"),
+          tokens.TagCloseOpen(), tokens.Text(text="italic text"),
+          tokens.TagOpenClose(), tokens.Text(text="i"),
+          tokens.TagCloseClose()],
+         wrap([Tag(wraptext("i"), wraptext("italic text"),
+                   wiki_markup="''")])),
+
+        # * bullet
+        ([tokens.TagOpenOpen(wiki_markup="*"), tokens.Text(text="li"),
+          tokens.TagCloseSelfclose(), tokens.Text(text=" bullet")],
+         wrap([Tag(wraptext("li"), wiki_markup="*", self_closing=True),
+               Text(" bullet")])),
+    ])
+    def test_tag(self, builder, test, valid):
         """tests for building Tag nodes"""
-        tests = [
-            # <ref></ref>
-            ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
-              tokens.TagCloseOpen(padding=""), tokens.TagOpenClose(),
-              tokens.Text(text="ref"), tokens.TagCloseClose()],
-             wrap([Tag(wraptext("ref"), wrap([]),
-                       closing_tag=wraptext("ref"))])),
-
-            # <ref name></ref>
-            ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
-              tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
-                                  pad_after_eq=""),
-              tokens.Text(text="name"), tokens.TagCloseOpen(padding=""),
-              tokens.TagOpenClose(), tokens.Text(text="ref"),
-              tokens.TagCloseClose()],
-             wrap([Tag(wraptext("ref"), wrap([]),
-                      attrs=[Attribute(wraptext("name"))])])),
-
-            # <ref name="abc" />
-            ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
-              tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
-                                  pad_after_eq=""),
-              tokens.Text(text="name"), tokens.TagAttrEquals(),
-              tokens.TagAttrQuote(char='"'), tokens.Text(text="abc"),
-              tokens.TagCloseSelfclose(padding=" ")],
-             wrap([Tag(wraptext("ref"),
-                       attrs=[Attribute(wraptext("name"), wraptext("abc"))],
-                       self_closing=True, padding=" ")])),
-
-            # <br/>
-            ([tokens.TagOpenOpen(), tokens.Text(text="br"),
-              tokens.TagCloseSelfclose(padding="")],
-             wrap([Tag(wraptext("br"), self_closing=True)])),
-
-            # <li>
-            ([tokens.TagOpenOpen(), tokens.Text(text="li"),
-              tokens.TagCloseSelfclose(padding="", implicit=True)],
-             wrap([Tag(wraptext("li"), self_closing=True, implicit=True)])),
-
-            # </br>
-            ([tokens.TagOpenOpen(invalid=True), tokens.Text(text="br"),
-              tokens.TagCloseSelfclose(padding="", implicit=True)],
-             wrap([Tag(wraptext("br"), self_closing=True, invalid=True,
-                       implicit=True)])),
-
-            # </br/>
-            ([tokens.TagOpenOpen(invalid=True), tokens.Text(text="br"),
-              tokens.TagCloseSelfclose(padding="")],
-             wrap([Tag(wraptext("br"), self_closing=True, invalid=True)])),
-
-            # <ref name={{abc}}   foo="bar {{baz}}" abc={{de}}f ghi=j{{k}}{{l}}
-            #      mno =  '{{p}} [[q]] {{r}}'>[[Source]]</ref>
-            ([tokens.TagOpenOpen(), tokens.Text(text="ref"),
-              tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
-                                  pad_after_eq=""),
-              tokens.Text(text="name"), tokens.TagAttrEquals(),
-              tokens.TemplateOpen(), tokens.Text(text="abc"),
-              tokens.TemplateClose(),
-              tokens.TagAttrStart(pad_first="   ", pad_before_eq="",
-                                  pad_after_eq=""),
-              tokens.Text(text="foo"), tokens.TagAttrEquals(),
-              tokens.TagAttrQuote(char='"'), tokens.Text(text="bar "),
-              tokens.TemplateOpen(), tokens.Text(text="baz"),
-              tokens.TemplateClose(),
-              tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
-                                  pad_after_eq=""),
-              tokens.Text(text="abc"), tokens.TagAttrEquals(),
-              tokens.TemplateOpen(), tokens.Text(text="de"),
-              tokens.TemplateClose(), tokens.Text(text="f"),
-              tokens.TagAttrStart(pad_first=" ", pad_before_eq="",
-                                  pad_after_eq=""),
-              tokens.Text(text="ghi"), tokens.TagAttrEquals(),
-              tokens.Text(text="j"), tokens.TemplateOpen(),
-              tokens.Text(text="k"), tokens.TemplateClose(),
-              tokens.TemplateOpen(), tokens.Text(text="l"),
-              tokens.TemplateClose(),
-              tokens.TagAttrStart(pad_first=" \n ", pad_before_eq=" ",
-                                  pad_after_eq="  "),
-              tokens.Text(text="mno"), tokens.TagAttrEquals(),
-              tokens.TagAttrQuote(char="'"), tokens.TemplateOpen(),
-              tokens.Text(text="p"), tokens.TemplateClose(),
-              tokens.Text(text=" "), tokens.WikilinkOpen(),
-              tokens.Text(text="q"), tokens.WikilinkClose(),
-              tokens.Text(text=" "), tokens.TemplateOpen(),
-              tokens.Text(text="r"), tokens.TemplateClose(),
-              tokens.TagCloseOpen(padding=""), tokens.WikilinkOpen(),
-              tokens.Text(text="Source"), tokens.WikilinkClose(),
-              tokens.TagOpenClose(), tokens.Text(text="ref"),
-              tokens.TagCloseClose()],
-             wrap([Tag(wraptext("ref"), wrap([Wikilink(wraptext("Source"))]), [
-                    Attribute(wraptext("name"),
-                              wrap([Template(wraptext("abc"))]), None),
-                    Attribute(wraptext("foo"), wrap([Text("bar "),
-                              Template(wraptext("baz"))]), pad_first="   "),
-                    Attribute(wraptext("abc"), wrap([Template(wraptext("de")),
-                              Text("f")]), None),
-                    Attribute(wraptext("ghi"), wrap([Text("j"),
-                              Template(wraptext("k")),
-                              Template(wraptext("l"))]), None),
-                    Attribute(wraptext("mno"), wrap([Template(wraptext("p")),
-                              Text(" "), Wikilink(wraptext("q")), Text(" "),
-                              Template(wraptext("r"))]), "'", " \n ", " ",
-                              "  ")])])),
-
-            # "''italic text''"
-            ([tokens.TagOpenOpen(wiki_markup="''"), tokens.Text(text="i"),
-              tokens.TagCloseOpen(), tokens.Text(text="italic text"),
-              tokens.TagOpenClose(), tokens.Text(text="i"),
-              tokens.TagCloseClose()],
-             wrap([Tag(wraptext("i"), wraptext("italic text"),
-                       wiki_markup="''")])),
-
-            # * bullet
-            ([tokens.TagOpenOpen(wiki_markup="*"), tokens.Text(text="li"),
-              tokens.TagCloseSelfclose(), tokens.Text(text=" bullet")],
-             wrap([Tag(wraptext("li"), wiki_markup="*", self_closing=True),
-                   Text(" bullet")])),
-        ]
-        for test, valid in tests:
-            self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_integration(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    def test_integration(self, builder):
         """a test for building a combination of templates together"""
         # {{{{{{{{foo}}bar|baz=biz}}buzz}}usr|{{bin}}}}
         test = [tokens.TemplateOpen(), tokens.TemplateOpen(),
@@ -380,9 +372,9 @@ class TestBuilder(TreeEqualityTestCase):
             wraptext("biz"))]), Text("buzz")])), Text("usr")]), params=[
             Parameter(wraptext("1"), wrap([Template(wraptext("bin"))]),
             showkey=False)])])
-        self.assertWikicodeEqual(valid, self.builder.build(test))
+        self.assertWikicodeEqual(valid, builder.build(test))
 
-    def test_integration2(self):
+    def test_integration2(self, builder):
         """an even more audacious test for building a horrible wikicode mess"""
         # {{a|b|{{c|[[d]]{{{e}}}}}}}[[f|{{{g}}}<!--h-->]]{{i|j=&nbsp;}}
         test = [tokens.TemplateOpen(), tokens.Text(text="a"),
@@ -412,23 +404,24 @@ class TestBuilder(TreeEqualityTestCase):
             "g")), Comment("h")])), Template(wraptext("i"), params=[
             Parameter(wraptext("j"), wrap([HTMLEntity("nbsp",
             named=True)]))])])
-        self.assertWikicodeEqual(valid, self.builder.build(test))
-
-    def test_parser_errors(self):
+        self.assertWikicodeEqual(valid, builder.build(test))
+
+    @pytest.mark.parametrize("tokens", [
+        [tokens.TemplateOpen(), tokens.TemplateParamSeparator()],
+        [tokens.TemplateOpen()], [tokens.ArgumentOpen()],
+        [tokens.WikilinkOpen()], [tokens.ExternalLinkOpen()],
+        [tokens.HeadingStart()], [tokens.CommentStart()],
+        [tokens.TagOpenOpen(), tokens.TagAttrStart()],
+        [tokens.TagOpenOpen()]
+    ])
+    def test_parser_errors(self, builder, tokens):
         """test whether ParserError gets thrown for bad input"""
-        missing_closes = [
-            [tokens.TemplateOpen(), tokens.TemplateParamSeparator()],
-            [tokens.TemplateOpen()], [tokens.ArgumentOpen()],
-            [tokens.WikilinkOpen()], [tokens.ExternalLinkOpen()],
-            [tokens.HeadingStart()], [tokens.CommentStart()],
-            [tokens.TagOpenOpen(), tokens.TagAttrStart()],
-            [tokens.TagOpenOpen()]
-        ]
-
-        msg = r"_handle_token\(\) got unexpected TemplateClose"
-        self.assertRaisesRegex(ParserError, msg, self.builder.build, [tokens.TemplateClose()])
-        for test in missing_closes:
-            self.assertRaises(ParserError, self.builder.build, test)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        with pytest.raises(ParserError):
+            builder.build(tokens)
+
+    def test_parser_errors_templateclose(self, builder):
+        with pytest.raises(
+                ParserError,
+                match=r"_handle_token\(\) got unexpected TemplateClose"
+        ):
+            builder.build([tokens.TemplateClose()])

tests/test_comment.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import Comment
 
@@ -31,32 +31,30 @@ class TestComment(TreeEqualityTestCase):
     def test_unicode(self):
         """test Comment.__unicode__()"""
         node = Comment("foobar")
-        self.assertEqual("<!--foobar-->", str(node))
+        assert "<!--foobar-->" == str(node)
 
     def test_children(self):
         """test Comment.__children__()"""
         node = Comment("foobar")
         gen = node.__children__()
-        self.assertRaises(StopIteration, next, gen)
+        with pytest.raises(StopIteration):
+            next(gen)
 
     def test_strip(self):
         """test Comment.__strip__()"""
         node = Comment("foobar")
-        self.assertIs(None, node.__strip__())
+        assert node.__strip__() is None
 
     def test_showtree(self):
         """test Comment.__showtree__()"""
         output = []
         node = Comment("foobar")
         node.__showtree__(output.append, None, None)
-        self.assertEqual(["<!--foobar-->"], output)
+        assert ["<!--foobar-->"] == output
 
     def test_contents(self):
         """test getter/setter for the contents attribute"""
         node = Comment("foobar")
-        self.assertEqual("foobar", node.contents)
+        assert "foobar" == node.contents
         node.contents = "barfoo"
-        self.assertEqual("barfoo", node.contents)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert "barfoo" == node.contents

tests/test_ctokenizer.py

@@ -1,46 +0,0 @@
-#
-# Copyright (C) 2012-2016 Ben Kurtovic <ben.kurtovic@gmail.com>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-import unittest
-
-try:
-    from mwparserfromhell.parser._tokenizer import CTokenizer
-except ImportError:
-    CTokenizer = None
-
-from ._test_tokenizer import TokenizerTestCase
-
-@unittest.skipUnless(CTokenizer, "C tokenizer not available")
-class TestCTokenizer(TokenizerTestCase, unittest.TestCase):
-    """Test cases for the C tokenizer."""
-
-    @classmethod
-    def setUpClass(cls):
-        cls.tokenizer = CTokenizer
-
-    if not TokenizerTestCase.skip_others:
-        def test_uses_c(self):
-            """make sure the C tokenizer identifies as using a C extension"""
-            self.assertTrue(CTokenizer.USES_C)
-            self.assertTrue(CTokenizer().USES_C)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

tests/test_docs.py

@@ -22,13 +22,13 @@
 import json
 from io import StringIO
 import os
-import unittest
+import pytest
 from urllib.parse import urlencode
 from urllib.request import urlopen
 
 import mwparserfromhell
 
-class TestDocs(unittest.TestCase):
+class TestDocs:
     """Integration test cases for mwparserfromhell's documentation."""
 
     def assertPrint(self, input, output):
@@ -36,7 +36,7 @@ class TestDocs(unittest.TestCase):
         buff = StringIO()
         print(input, end="", file=buff)
         buff.seek(0)
-        self.assertEqual(output, buff.read())
+        assert output == buff.read()
 
     def test_readme_1(self):
         """test a block of example code in the README"""
@@ -88,9 +88,9 @@ class TestDocs(unittest.TestCase):
         text = str(code)
         res = "{{cleanup|date=July 2012}} '''Foo''' is a [[bar]]. {{bar-stub}}"
         self.assertPrint(text, res)
-        self.assertEqual(text, code)
+        assert text == code
 
-    @unittest.skipIf("NOWEB" in os.environ, "web test disabled by environ var")
+    @pytest.mark.skipif("NOWEB" in os.environ, reason="web test disabled by environ var")
     def test_readme_5(self):
         """test a block of example code in the README; includes a web call"""
         url1 = "https://en.wikipedia.org/w/api.php"
@@ -109,16 +109,13 @@ class TestDocs(unittest.TestCase):
         try:
             raw = urlopen(url1, urlencode(data).encode("utf8")).read()
         except OSError:
-            self.skipTest("cannot continue because of unsuccessful web call")
+            pytest.skip("cannot continue because of unsuccessful web call")
         res = json.loads(raw.decode("utf8"))
         revision = res["query"]["pages"][0]["revisions"][0]
         text = revision["slots"]["main"]["content"]
         try:
             expected = urlopen(url2.format(title)).read().decode("utf8")
         except OSError:
-            self.skipTest("cannot continue because of unsuccessful web call")
+            pytest.skip("cannot continue because of unsuccessful web call")
         actual = mwparserfromhell.parse(text)
-        self.assertEqual(expected, actual)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert expected == actual

tests/test_external_link.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import ExternalLink, Text
 
@@ -31,14 +31,14 @@ class TestExternalLink(TreeEqualityTestCase):
     def test_unicode(self):
         """test ExternalLink.__unicode__()"""
         node = ExternalLink(wraptext("http://example.com/"), brackets=False)
-        self.assertEqual("http://example.com/", str(node))
+        assert "http://example.com/" == str(node)
         node2 = ExternalLink(wraptext("http://example.com/"))
-        self.assertEqual("[http://example.com/]", str(node2))
+        assert "[http://example.com/]" == str(node2)
         node3 = ExternalLink(wraptext("http://example.com/"), wrap([]))
-        self.assertEqual("[http://example.com/ ]", str(node3))
+        assert "[http://example.com/ ]" == str(node3)
         node4 = ExternalLink(wraptext("http://example.com/"),
                              wraptext("Example Web Page"))
-        self.assertEqual("[http://example.com/ Example Web Page]", str(node4))
+        assert "[http://example.com/ Example Web Page]" == str(node4)
 
     def test_children(self):
         """test ExternalLink.__children__()"""
@@ -47,11 +47,13 @@ class TestExternalLink(TreeEqualityTestCase):
                              wrap([Text("Example"), Text("Page")]))
         gen1 = node1.__children__()
         gen2 = node2.__children__()
-        self.assertEqual(node1.url, next(gen1))
-        self.assertEqual(node2.url, next(gen2))
-        self.assertEqual(node2.title, next(gen2))
-        self.assertRaises(StopIteration, next, gen1)
-        self.assertRaises(StopIteration, next, gen2)
+        assert node1.url == next(gen1)
+        assert node2.url == next(gen2)
+        assert node2.title == next(gen2)
+        with pytest.raises(StopIteration):
+            next(gen1)
+        with pytest.raises(StopIteration):
+            next(gen2)
 
     def test_strip(self):
         """test ExternalLink.__strip__()"""
@@ -60,10 +62,10 @@ class TestExternalLink(TreeEqualityTestCase):
         node3 = ExternalLink(wraptext("http://example.com"), wrap([]))
         node4 = ExternalLink(wraptext("http://example.com"), wraptext("Link"))
 
-        self.assertEqual("http://example.com", node1.__strip__())
-        self.assertEqual(None, node2.__strip__())
-        self.assertEqual(None, node3.__strip__())
-        self.assertEqual("Link", node4.__strip__())
+        assert "http://example.com" == node1.__strip__()
+        assert node2.__strip__() is None
+        assert node3.__strip__() is None
+        assert "Link" == node4.__strip__()
 
     def test_showtree(self):
         """test ExternalLink.__showtree__()"""
@@ -78,15 +80,15 @@ class TestExternalLink(TreeEqualityTestCase):
         valid = [
             (getter, node1.url), "[", (getter, node2.url),
             (getter, node2.title), "]"]
-        self.assertEqual(valid, output)
+        assert valid == output
 
     def test_url(self):
         """test getter/setter for the url attribute"""
         url = wraptext("http://example.com/")
         node1 = ExternalLink(url, brackets=False)
         node2 = ExternalLink(url, wraptext("Example"))
-        self.assertIs(url, node1.url)
-        self.assertIs(url, node2.url)
+        assert url is node1.url
+        assert url is node2.url
         node1.url = "mailto:héhehé@spam.com"
         node2.url = "mailto:héhehé@spam.com"
         self.assertWikicodeEqual(wraptext("mailto:héhehé@spam.com"), node1.url)
@@ -97,10 +99,10 @@ class TestExternalLink(TreeEqualityTestCase):
         title = wraptext("Example!")
         node1 = ExternalLink(wraptext("http://example.com/"), brackets=False)
         node2 = ExternalLink(wraptext("http://example.com/"), title)
-        self.assertIs(None, node1.title)
-        self.assertIs(title, node2.title)
+        assert None is node1.title
+        assert title is node2.title
         node2.title = None
-        self.assertIs(None, node2.title)
+        assert None is node2.title
         node2.title = "My Website"
         self.assertWikicodeEqual(wraptext("My Website"), node2.title)
 
@@ -108,14 +110,11 @@ class TestExternalLink(TreeEqualityTestCase):
         """test getter/setter for the brackets attribute"""
         node1 = ExternalLink(wraptext("http://example.com/"), brackets=False)
         node2 = ExternalLink(wraptext("http://example.com/"), wraptext("Link"))
-        self.assertFalse(node1.brackets)
-        self.assertTrue(node2.brackets)
+        assert node1.brackets is False
+        assert node2.brackets is True
         node1.brackets = True
         node2.brackets = False
-        self.assertTrue(node1.brackets)
-        self.assertFalse(node2.brackets)
-        self.assertEqual("[http://example.com/]", str(node1))
-        self.assertEqual("http://example.com/", str(node2))
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert node1.brackets is True
+        assert node2.brackets is False
+        assert "[http://example.com/]" == str(node1)
+        assert "http://example.com/" == str(node2)

tests/test_heading.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import Heading, Text
 
@@ -31,21 +31,22 @@ class TestHeading(TreeEqualityTestCase):
     def test_unicode(self):
         """test Heading.__unicode__()"""
         node = Heading(wraptext("foobar"), 2)
-        self.assertEqual("==foobar==", str(node))
+        assert "==foobar==" == str(node)
         node2 = Heading(wraptext(" zzz "), 5)
-        self.assertEqual("===== zzz =====", str(node2))
+        assert "===== zzz =====" == str(node2)
 
     def test_children(self):
         """test Heading.__children__()"""
         node = Heading(wrap([Text("foo"), Text("bar")]), 3)
         gen = node.__children__()
-        self.assertEqual(node.title, next(gen))
-        self.assertRaises(StopIteration, next, gen)
+        assert node.title == next(gen)
+        with pytest.raises(StopIteration):
+            next(gen)
 
     def test_strip(self):
         """test Heading.__strip__()"""
         node = Heading(wraptext("foobar"), 3)
-        self.assertEqual("foobar", node.__strip__())
+        assert "foobar" == node.__strip__()
 
     def test_showtree(self):
         """test Heading.__showtree__()"""
@@ -58,26 +59,27 @@ class TestHeading(TreeEqualityTestCase):
         node2.__showtree__(output.append, get, None)
         valid = ["===", (getter, node1.title), "===",
                  "====", (getter, node2.title), "===="]
-        self.assertEqual(valid, output)
+        assert valid == output
 
     def test_title(self):
         """test getter/setter for the title attribute"""
         title = wraptext("foobar")
         node = Heading(title, 3)
-        self.assertIs(title, node.title)
+        assert title is node.title
         node.title = "héhehé"
         self.assertWikicodeEqual(wraptext("héhehé"), node.title)
 
     def test_level(self):
         """test getter/setter for the level attribute"""
         node = Heading(wraptext("foobar"), 3)
-        self.assertEqual(3, node.level)
+        assert 3 == node.level
         node.level = 5
-        self.assertEqual(5, node.level)
-        self.assertRaises(ValueError, setattr, node, "level", 0)
-        self.assertRaises(ValueError, setattr, node, "level", 7)
-        self.assertRaises(ValueError, setattr, node, "level", "abc")
-        self.assertRaises(ValueError, setattr, node, "level", False)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert 5 == node.level
+        with pytest.raises(ValueError):
+            node.__setattr__("level", 0)
+        with pytest.raises(ValueError):
+            node.__setattr__("level", 7)
+        with pytest.raises(ValueError):
+            node.__setattr__("level", "abc")
+        with pytest.raises(ValueError):
+            node.__setattr__("level", False)

tests/test_html_entity.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell.nodes import HTMLEntity
 
@@ -34,16 +34,17 @@ class TestHTMLEntity(TreeEqualityTestCase):
         node2 = HTMLEntity("107", named=False, hexadecimal=False)
         node3 = HTMLEntity("6b", named=False, hexadecimal=True)
         node4 = HTMLEntity("6C", named=False, hexadecimal=True, hex_char="X")
-        self.assertEqual(" ", str(node1))
-        self.assertEqual("k", str(node2))
-        self.assertEqual("k", str(node3))
-        self.assertEqual("l", str(node4))
+        assert " " == str(node1)
+        assert "k" == str(node2)
+        assert "k" == str(node3)
+        assert "l" == str(node4)
 
     def test_children(self):
         """test HTMLEntity.__children__()"""
         node = HTMLEntity("nbsp", named=True, hexadecimal=False)
         gen = node.__children__()
-        self.assertRaises(StopIteration, next, gen)
+        with pytest.raises(StopIteration):
+            next(gen)
 
     def test_strip(self):
         """test HTMLEntity.__strip__()"""
@@ -51,12 +52,12 @@ class TestHTMLEntity(TreeEqualityTestCase):
         node2 = HTMLEntity("107", named=False, hexadecimal=False)
         node3 = HTMLEntity("e9", named=False, hexadecimal=True)
 
-        self.assertEqual("\xa0", node1.__strip__(normalize=True))
-        self.assertEqual(" ", node1.__strip__(normalize=False))
-        self.assertEqual("k", node2.__strip__(normalize=True))
-        self.assertEqual("k", node2.__strip__(normalize=False))
-        self.assertEqual("é", node3.__strip__(normalize=True))
-        self.assertEqual("é", node3.__strip__(normalize=False))
+        assert "\xa0" == node1.__strip__(normalize=True)
+        assert " " == node1.__strip__(normalize=False)
+        assert "k" == node2.__strip__(normalize=True)
+        assert "k" == node2.__strip__(normalize=False)
+        assert "é" == node3.__strip__(normalize=True)
+        assert "é" == node3.__strip__(normalize=False)
 
     def test_showtree(self):
         """test HTMLEntity.__showtree__()"""
@@ -68,88 +69,102 @@ class TestHTMLEntity(TreeEqualityTestCase):
         node2.__showtree__(output.append, None, None)
         node3.__showtree__(output.append, None, None)
         res = [" ", "k", "é"]
-        self.assertEqual(res, output)
+        assert res == output
 
     def test_value(self):
         """test getter/setter for the value attribute"""
         node1 = HTMLEntity("nbsp")
         node2 = HTMLEntity("107")
         node3 = HTMLEntity("e9")
-        self.assertEqual("nbsp", node1.value)
-        self.assertEqual("107", node2.value)
-        self.assertEqual("e9", node3.value)
+        assert "nbsp" == node1.value
+        assert "107" == node2.value
+        assert "e9" == node3.value
 
         node1.value = "ffa4"
         node2.value = 72
         node3.value = "Sigma"
-        self.assertEqual("ffa4", node1.value)
-        self.assertFalse(node1.named)
-        self.assertTrue(node1.hexadecimal)
-        self.assertEqual("72", node2.value)
-        self.assertFalse(node2.named)
-        self.assertFalse(node2.hexadecimal)
-        self.assertEqual("Sigma", node3.value)
-        self.assertTrue(node3.named)
-        self.assertFalse(node3.hexadecimal)
+        assert "ffa4" == node1.value
+        assert node1.named is False
+        assert node1.hexadecimal is True
+        assert "72" == node2.value
+        assert node2.named is False
+        assert node2.hexadecimal is False
+        assert "Sigma" == node3.value
+        assert node3.named is True
+        assert node3.hexadecimal is False
 
         node1.value = "10FFFF"
         node2.value = 110000
         node2.value = 1114111
-        self.assertRaises(ValueError, setattr, node3, "value", "")
-        self.assertRaises(ValueError, setattr, node3, "value", "foobar")
-        self.assertRaises(ValueError, setattr, node3, "value", True)
-        self.assertRaises(ValueError, setattr, node3, "value", -1)
-        self.assertRaises(ValueError, setattr, node1, "value", 110000)
-        self.assertRaises(ValueError, setattr, node1, "value", "1114112")
-        self.assertRaises(ValueError, setattr, node1, "value", "12FFFF")
+        with pytest.raises(ValueError):
+            node3.__setattr__("value", "")
+        with pytest.raises(ValueError):
+            node3.__setattr__("value", "foobar")
+        with pytest.raises(ValueError):
+            node3.__setattr__("value", True)
+        with pytest.raises(ValueError):
+            node3.__setattr__("value", -1)
+        with pytest.raises(ValueError):
+            node1.__setattr__("value", 110000)
+        with pytest.raises(ValueError):
+            node1.__setattr__("value", "1114112")
+        with pytest.raises(ValueError):
+            node1.__setattr__("value", "12FFFF")
 
     def test_named(self):
         """test getter/setter for the named attribute"""
         node1 = HTMLEntity("nbsp")
         node2 = HTMLEntity("107")
         node3 = HTMLEntity("e9")
-        self.assertTrue(node1.named)
-        self.assertFalse(node2.named)
-        self.assertFalse(node3.named)
+        assert node1.named is True
+        assert node2.named is False
+        assert node3.named is False
         node1.named = 1
         node2.named = 0
         node3.named = 0
-        self.assertTrue(node1.named)
-        self.assertFalse(node2.named)
-        self.assertFalse(node3.named)
-        self.assertRaises(ValueError, setattr, node1, "named", False)
-        self.assertRaises(ValueError, setattr, node2, "named", True)
-        self.assertRaises(ValueError, setattr, node3, "named", True)
+        assert node1.named is True
+        assert node2.named is False
+        assert node3.named is False
+        with pytest.raises(ValueError):
+            node1.__setattr__("named", False)
+        with pytest.raises(ValueError):
+            node2.__setattr__("named", True)
+        with pytest.raises(ValueError):
+            node3.__setattr__("named", True)
 
     def test_hexadecimal(self):
         """test getter/setter for the hexadecimal attribute"""
         node1 = HTMLEntity("nbsp")
         node2 = HTMLEntity("107")
         node3 = HTMLEntity("e9")
-        self.assertFalse(node1.hexadecimal)
-        self.assertFalse(node2.hexadecimal)
-        self.assertTrue(node3.hexadecimal)
+        assert node1.hexadecimal is False
+        assert node2.hexadecimal is False
+        assert node3.hexadecimal is True
         node1.hexadecimal = False
         node2.hexadecimal = True
         node3.hexadecimal = False
-        self.assertFalse(node1.hexadecimal)
-        self.assertTrue(node2.hexadecimal)
-        self.assertFalse(node3.hexadecimal)
-        self.assertRaises(ValueError, setattr, node1, "hexadecimal", True)
+        assert node1.hexadecimal is False
+        assert node2.hexadecimal is True
+        assert node3.hexadecimal is False
+        with pytest.raises(ValueError):
+            node1.__setattr__("hexadecimal", True)
 
     def test_hex_char(self):
         """test getter/setter for the hex_char attribute"""
         node1 = HTMLEntity("e9")
         node2 = HTMLEntity("e9", hex_char="X")
-        self.assertEqual("x", node1.hex_char)
-        self.assertEqual("X", node2.hex_char)
+        assert "x" == node1.hex_char
+        assert "X" == node2.hex_char
         node1.hex_char = "X"
         node2.hex_char = "x"
-        self.assertEqual("X", node1.hex_char)
-        self.assertEqual("x", node2.hex_char)
-        self.assertRaises(ValueError, setattr, node1, "hex_char", 123)
-        self.assertRaises(ValueError, setattr, node1, "hex_char", "foobar")
-        self.assertRaises(ValueError, setattr, node1, "hex_char", True)
+        assert "X" == node1.hex_char
+        assert "x" == node2.hex_char
+        with pytest.raises(ValueError):
+            node1.__setattr__("hex_char", 123)
+        with pytest.raises(ValueError):
+            node1.__setattr__("hex_char", "foobar")
+        with pytest.raises(ValueError):
+            node1.__setattr__("hex_char", True)
 
     def test_normalize(self):
         """test getter/setter for the normalize attribute"""
@@ -159,12 +174,11 @@ class TestHTMLEntity(TreeEqualityTestCase):
         node4 = HTMLEntity("1f648")
         node5 = HTMLEntity("-2")
         node6 = HTMLEntity("110000", named=False, hexadecimal=True)
-        self.assertEqual("\xa0", node1.normalize())
-        self.assertEqual("k", node2.normalize())
-        self.assertEqual("é", node3.normalize())
-        self.assertEqual("\U0001F648", node4.normalize())
-        self.assertRaises(ValueError, node5.normalize)
-        self.assertRaises(ValueError, node6.normalize)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert "\xa0" == node1.normalize()
+        assert "k" == node2.normalize()
+        assert "é" == node3.normalize()
+        assert "\U0001F648" == node4.normalize()
+        with pytest.raises(ValueError):
+            node5.normalize()
+        with pytest.raises(ValueError):
+            node6.normalize()

tests/test_parameter.py

@@ -19,9 +19,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
-from mwparserfromhell.nodes import Text
 from mwparserfromhell.nodes.extras import Parameter
 
 from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext
@@ -32,9 +31,9 @@ class TestParameter(TreeEqualityTestCase):
     def test_unicode(self):
         """test Parameter.__unicode__()"""
         node = Parameter(wraptext("1"), wraptext("foo"), showkey=False)
-        self.assertEqual("foo", str(node))
+        assert "foo" == str(node)
         node2 = Parameter(wraptext("foo"), wraptext("bar"))
-        self.assertEqual("foo=bar", str(node2))
+        assert "foo=bar" == str(node2)
 
     def test_name(self):
         """test getter/setter for the name attribute"""
@@ -42,8 +41,8 @@ class TestParameter(TreeEqualityTestCase):
         name2 = wraptext("foobar")
         node1 = Parameter(name1, wraptext("foobar"), showkey=False)
         node2 = Parameter(name2, wraptext("baz"))
-        self.assertIs(name1, node1.name)
-        self.assertIs(name2, node2.name)
+        assert name1 is node1.name
+        assert name2 is node2.name
         node1.name = "héhehé"
         node2.name = "héhehé"
         self.assertWikicodeEqual(wraptext("héhehé"), node1.name)
@@ -53,7 +52,7 @@ class TestParameter(TreeEqualityTestCase):
         """test getter/setter for the value attribute"""
         value = wraptext("bar")
         node = Parameter(wraptext("foo"), value)
-        self.assertIs(value, node.value)
+        assert value is node.value
         node.value = "héhehé"
         self.assertWikicodeEqual(wraptext("héhehé"), node.value)
 
@@ -61,13 +60,11 @@ class TestParameter(TreeEqualityTestCase):
         """test getter/setter for the showkey attribute"""
         node1 = Parameter(wraptext("1"), wraptext("foo"), showkey=False)
         node2 = Parameter(wraptext("foo"), wraptext("bar"))
-        self.assertFalse(node1.showkey)
-        self.assertTrue(node2.showkey)
+        assert node1.showkey is False
+        assert node2.showkey is True
         node1.showkey = True
-        self.assertTrue(node1.showkey)
+        assert node1.showkey is True
         node1.showkey = ""
-        self.assertFalse(node1.showkey)
-        self.assertRaises(ValueError, setattr, node2, "showkey", False)
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        assert node1.showkey is False
+        with pytest.raises(ValueError):
+            node2.__setattr__("showkey", False)

tests/test_parser.py

@@ -19,7 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-import unittest
+import pytest
 
 from mwparserfromhell import parser
 from mwparserfromhell.nodes import Tag, Template, Text, Wikilink
@@ -30,16 +30,19 @@ from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext
 class TestParser(TreeEqualityTestCase):
     """Tests for the Parser class itself, which tokenizes and builds nodes."""
 
-    def test_use_c(self):
+    @pytest.fixture()
+    def pyparser(self):
         """make sure the correct tokenizer is used"""
         restore = parser.use_c
         if parser.use_c:
-            self.assertTrue(parser.Parser()._tokenizer.USES_C)
             parser.use_c = False
-        self.assertFalse(parser.Parser()._tokenizer.USES_C)
+        yield
         parser.use_c = restore
 
-    def test_parsing(self):
+    def test_use_c(self, pyparser):
+        assert parser.Parser()._tokenizer.USES_C is False
+
+    def test_parsing(self, pyparser):
         """integration test for parsing overall"""
         text = "this is text; {{this|is=a|template={{with|[[links]]|in}}it}}"
         expected = wrap([
@@ -61,26 +64,15 @@ class TestParser(TreeEqualityTestCase):
         actual = parser.Parser().parse(text)
         self.assertWikicodeEqual(expected, actual)
 
-    def test_skip_style_tags(self):
+    def test_skip_style_tags(self, pyparser):
         """test Parser.parse(skip_style_tags=True)"""
-        def test():
-            with_style = parser.Parser().parse(text, skip_style_tags=False)
-            without_style = parser.Parser().parse(text, skip_style_tags=True)
-            self.assertWikicodeEqual(a, with_style)
-            self.assertWikicodeEqual(b, without_style)
-
         text = "This is an example with ''italics''!"
         a = wrap([Text("This is an example with "),
                   Tag(wraptext("i"), wraptext("italics"), wiki_markup="''"),
                   Text("!")])
         b = wraptext("This is an example with ''italics''!")
 
-        restore = parser.use_c
-        if parser.use_c:
-            test()
-            parser.use_c = False
-        test()
-        parser.use_c = restore
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)
+        with_style = parser.Parser().parse(text, skip_style_tags=False)
+        without_style = parser.Parser().parse(text, skip_style_tags=True)
+        self.assertWikicodeEqual(a, with_style)
+        self.assertWikicodeEqual(b, without_style)

tests/test_pytokenizer.py

@@ -1,48 +0,0 @@
-#
-# Copyright (C) 2012-2019 Ben Kurtovic <ben.kurtovic@gmail.com>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell