From 3fe629f54188a0f5ffde439811aab656a0418f0c Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 4 May 2013 16:18:14 -0400 Subject: [PATCH] Condense usage of wrap([Text("foo")]) to just wraptext("foo"). --- tests/_test_tree_equality.py | 2 +- tests/test_argument.py | 30 ++++++++-------- tests/test_builder.py | 85 +++++++++++++++++++++----------------------- tests/test_heading.py | 20 +++++------ tests/test_parameter.py | 28 +++++++-------- tests/test_parser.py | 21 +++++------ tests/test_utils.py | 27 ++++++-------- tests/test_wikilink.py | 30 ++++++++-------- 8 files changed, 114 insertions(+), 129 deletions(-) diff --git a/tests/_test_tree_equality.py b/tests/_test_tree_equality.py index 6d9b26a..52130ed 100644 --- a/tests/_test_tree_equality.py +++ b/tests/_test_tree_equality.py @@ -30,7 +30,7 @@ from mwparserfromhell.smart_list import SmartList from mwparserfromhell.wikicode import Wikicode wrap = lambda L: Wikicode(SmartList(L)) -wraptext = lambda t: wrap([Text(t)]) +wraptext = lambda *args: wrap([Text(t) for t in args]) def getnodes(code): """Iterate over all child nodes of a given parent node. diff --git a/tests/test_argument.py b/tests/test_argument.py index a9469d4..8191804 100644 --- a/tests/test_argument.py +++ b/tests/test_argument.py @@ -26,16 +26,16 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Argument, Text -from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext class TestArgument(TreeEqualityTestCase): """Test cases for the Argument node.""" def test_unicode(self): """test Argument.__unicode__()""" - node = Argument(wrap([Text("foobar")])) + node = Argument(wraptext("foobar")) self.assertEqual("{{{foobar}}}", str(node)) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node2 = Argument(wraptext("foo"), wraptext("bar")) self.assertEqual("{{{foo|bar}}}", str(node2)) def test_iternodes(self): @@ -57,8 +57,8 @@ class TestArgument(TreeEqualityTestCase): def test_strip(self): """test Argument.__strip__()""" - node = Argument(wrap([Text("foobar")])) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node = Argument(wraptext("foobar")) + node2 = Argument(wraptext("foo"), wraptext("bar")) for a in (True, False): for b in (True, False): self.assertIs(None, node.__strip__(a, b)) @@ -70,8 +70,8 @@ class TestArgument(TreeEqualityTestCase): getter, marker = object(), object() get = lambda code: output.append((getter, code)) mark = lambda: output.append(marker) - node1 = Argument(wrap([Text("foobar")])) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node1 = Argument(wraptext("foobar")) + node2 = Argument(wraptext("foo"), wraptext("bar")) node1.__showtree__(output.append, get, mark) node2.__showtree__(output.append, get, mark) valid = [ @@ -81,26 +81,26 @@ class TestArgument(TreeEqualityTestCase): def test_name(self): """test getter/setter for the name attribute""" - name = wrap([Text("foobar")]) + name = wraptext("foobar") node1 = Argument(name) - node2 = Argument(name, wrap([Text("baz")])) + node2 = Argument(name, wraptext("baz")) self.assertIs(name, node1.name) self.assertIs(name, node2.name) node1.name = "héhehé" node2.name = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.name) - self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.name) + self.assertWikicodeEqual(wraptext("héhehé"), node1.name) + self.assertWikicodeEqual(wraptext("héhehé"), node2.name) def test_default(self): """test getter/setter for the default attribute""" - default = wrap([Text("baz")]) - node1 = Argument(wrap([Text("foobar")])) - node2 = Argument(wrap([Text("foobar")]), default) + default = wraptext("baz") + node1 = Argument(wraptext("foobar")) + node2 = Argument(wraptext("foobar"), default) self.assertIs(None, node1.default) self.assertIs(default, node2.default) node1.default = "buzz" node2.default = None - self.assertWikicodeEqual(wrap([Text("buzz")]), node1.default) + self.assertWikicodeEqual(wraptext("buzz"), node1.default) self.assertIs(None, node2.default) if __name__ == "__main__": diff --git a/tests/test_builder.py b/tests/test_builder.py index 76917e8..903d144 100644 --- a/tests/test_builder.py +++ b/tests/test_builder.py @@ -29,7 +29,7 @@ from mwparserfromhell.nodes.extras import Attribute, Parameter from mwparserfromhell.parser import tokens from mwparserfromhell.parser.builder import Builder -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext class TestBuilder(TreeEqualityTestCase): """Tests for the builder, which turns tokens into Wikicode objects.""" @@ -40,10 +40,10 @@ class TestBuilder(TreeEqualityTestCase): def test_text(self): """tests for building Text nodes""" tests = [ - ([tokens.Text(text="foobar")], wrap([Text("foobar")])), - ([tokens.Text(text="fóóbar")], wrap([Text("fóóbar")])), + ([tokens.Text(text="foobar")], wraptext("foobar")), + ([tokens.Text(text="fóóbar")], wraptext("fóóbar")), ([tokens.Text(text="spam"), tokens.Text(text="eggs")], - wrap([Text("spam"), Text("eggs")])), + wraptext("spam", "eggs")), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -53,25 +53,24 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.TemplateOpen(), tokens.Text(text="foobar"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foobar")]))])), + wrap([Template(wraptext("foobar"))])), ([tokens.TemplateOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.TemplateClose()], - wrap([Template(wrap([Text("spam"), Text("eggs")]))])), + wrap([Template(wraptext("spam", "eggs"))])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foo")]), params=[ - Parameter(wrap([Text("1")]), wrap([Text("bar")]), - showkey=False)])])), + 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(wrap([Text("foo")]), params=[ - Parameter(wrap([Text("bar")]), wrap([Text("baz")]))])])), + wrap([Template(wraptext("foo"), params=[ + Parameter(wraptext("bar"), wraptext("baz"))])])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), @@ -82,14 +81,12 @@ class TestBuilder(TreeEqualityTestCase): tokens.TemplateParamEquals(), tokens.Text(text="buff"), tokens.TemplateParamSeparator(), tokens.Text(text="baff"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foo")]), params=[ - Parameter(wrap([Text("bar")]), wrap([Text("baz")])), - Parameter(wrap([Text("1")]), wrap([Text("biz")]), - showkey=False), - Parameter(wrap([Text("2")]), wrap([Text("buzz")]), - showkey=False), - Parameter(wrap([Text("3")]), wrap([Text("buff")])), - Parameter(wrap([Text("3")]), wrap([Text("baff")]), + 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: @@ -100,23 +97,22 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.ArgumentOpen(), tokens.Text(text="foobar"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("foobar")]))])), + wrap([Argument(wraptext("foobar"))])), ([tokens.ArgumentOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("spam"), Text("eggs")]))])), + wrap([Argument(wraptext("spam", "eggs"))])), ([tokens.ArgumentOpen(), tokens.Text(text="foo"), tokens.ArgumentSeparator(), tokens.Text(text="bar"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("foo")]), wrap([Text("bar")]))])), + 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(wrap([Text("foo"), Text("bar")]), - wrap([Text("baz"), Text("biz")]))])), + wrap([Argument(wraptext("foo", "bar"), wraptext("baz", "biz"))])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -126,23 +122,22 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.WikilinkOpen(), tokens.Text(text="foobar"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("foobar")]))])), + wrap([Wikilink(wraptext("foobar"))])), ([tokens.WikilinkOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("spam"), Text("eggs")]))])), + wrap([Wikilink(wraptext("spam", "eggs"))])), ([tokens.WikilinkOpen(), tokens.Text(text="foo"), tokens.WikilinkSeparator(), tokens.Text(text="bar"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("foo")]), wrap([Text("bar")]))])), + 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(wrap([Text("foo"), Text("bar")]), - wrap([Text("baz"), Text("biz")]))])), + wrap([Wikilink(wraptext("foo", "bar"), wraptext("baz", "biz"))])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -172,11 +167,11 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.HeadingStart(level=2), tokens.Text(text="foobar"), tokens.HeadingEnd()], - wrap([Heading(wrap([Text("foobar")]), 2)])), + wrap([Heading(wraptext("foobar"), 2)])), ([tokens.HeadingStart(level=4), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.HeadingEnd()], - wrap([Heading(wrap([Text("spam"), Text("eggs")]), 4)])), + wrap([Heading(wraptext("spam", "eggs"), 4)])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -186,11 +181,11 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.CommentStart(), tokens.Text(text="foobar"), tokens.CommentEnd()], - wrap([Comment(wrap([Text("foobar")]))])), + wrap([Comment(wraptext("foobar"))])), ([tokens.CommentStart(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.CommentEnd()], - wrap([Comment(wrap([Text("spam"), Text("eggs")]))])), + wrap([Comment(wraptext("spam", "eggs"))])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -214,10 +209,10 @@ class TestBuilder(TreeEqualityTestCase): tokens.TemplateOpen(), tokens.Text(text="bin"), tokens.TemplateClose(), tokens.TemplateClose()] valid = wrap( - [Template(wrap([Template(wrap([Template(wrap([Template(wrap([Text( - "foo")])), Text("bar")]), params=[Parameter(wrap([Text("baz")]), - wrap([Text("biz")]))]), Text("buzz")])), Text("usr")]), params=[ - Parameter(wrap([Text("1")]), wrap([Template(wrap([Text("bin")]))]), + [Template(wrap([Template(wrap([Template(wrap([Template(wraptext( + "foo")), Text("bar")]), params=[Parameter(wraptext("baz"), + wraptext("biz"))]), Text("buzz")])), Text("usr")]), params=[ + Parameter(wraptext("1"), wrap([Template(wraptext("bin"))]), showkey=False)])]) self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -243,14 +238,14 @@ class TestBuilder(TreeEqualityTestCase): tokens.Text(text="nbsp"), tokens.HTMLEntityEnd(), tokens.TemplateClose()] valid = wrap( - [Template(wrap([Text("a")]), params=[Parameter(wrap([Text("1")]), - wrap([Text("b")]), showkey=False), Parameter(wrap([Text("2")]), - wrap([Template(wrap([Text("c")]), params=[Parameter(wrap([Text("1") - ]), wrap([Wikilink(wrap([Text("d")])), Argument(wrap([Text("e")]))] - ), showkey=False)])]), showkey=False)]), Wikilink(wrap([Text("f")] - ), wrap([Argument(wrap([Text("g")])), Comment(wrap([Text("h")]))]) - ), Template(wrap([Text("i")]), params=[Parameter(wrap([Text("j")]), - wrap([HTMLEntity("nbsp", named=True)]))])]) + [Template(wraptext("a"), params=[Parameter(wraptext("1"), wraptext( + "b"), showkey=False), Parameter(wraptext("2"), wrap([Template( + wraptext("c"), params=[Parameter(wraptext("1"), wrap([Wikilink( + wraptext("d")), Argument(wraptext("e"))]), showkey=False)])]), + showkey=False)]), Wikilink(wraptext("f"), wrap([Argument(wraptext( + "g")), Comment(wraptext("h"))])), Template(wraptext("i"), params=[ + Parameter(wraptext("j"), wrap([HTMLEntity("nbsp", + named=True)]))])]) self.assertWikicodeEqual(valid, self.builder.build(test)) if __name__ == "__main__": diff --git a/tests/test_heading.py b/tests/test_heading.py index 38f6545..7a65872 100644 --- a/tests/test_heading.py +++ b/tests/test_heading.py @@ -26,16 +26,16 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Heading, Text -from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext class TestHeading(TreeEqualityTestCase): """Test cases for the Heading node.""" def test_unicode(self): """test Heading.__unicode__()""" - node = Heading(wrap([Text("foobar")]), 2) + node = Heading(wraptext("foobar"), 2) self.assertEqual("==foobar==", str(node)) - node2 = Heading(wrap([Text(" zzz ")]), 5) + node2 = Heading(wraptext(" zzz "), 5) self.assertEqual("===== zzz =====", str(node2)) def test_iternodes(self): @@ -50,7 +50,7 @@ class TestHeading(TreeEqualityTestCase): def test_strip(self): """test Heading.__strip__()""" - node = Heading(wrap([Text("foobar")]), 3) + node = Heading(wraptext("foobar"), 3) for a in (True, False): for b in (True, False): self.assertEqual("foobar", node.__strip__(a, b)) @@ -60,8 +60,8 @@ class TestHeading(TreeEqualityTestCase): output = [] getter = object() get = lambda code: output.append((getter, code)) - node1 = Heading(wrap([Text("foobar")]), 3) - node2 = Heading(wrap([Text(" baz ")]), 4) + node1 = Heading(wraptext("foobar"), 3) + node2 = Heading(wraptext(" baz "), 4) node1.__showtree__(output.append, get, None) node2.__showtree__(output.append, get, None) valid = ["===", (getter, node1.title), "===", @@ -70,20 +70,18 @@ class TestHeading(TreeEqualityTestCase): def test_title(self): """test getter/setter for the title attribute""" - title = wrap([Text("foobar")]) + title = wraptext("foobar") node = Heading(title, 3) self.assertIs(title, node.title) node.title = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node.title) + self.assertWikicodeEqual(wraptext("héhehé"), node.title) def test_level(self): """test getter/setter for the level attribute""" - node = Heading(wrap([Text("foobar")]), 3) + node = Heading(wraptext("foobar"), 3) self.assertEqual(3, node.level) node.level = 5 self.assertEqual(5, node.level) - node.level = True - self.assertEqual(1, node.level) self.assertRaises(ValueError, setattr, node, "level", 0) self.assertRaises(ValueError, setattr, node, "level", 7) self.assertRaises(ValueError, setattr, node, "level", "abc") diff --git a/tests/test_parameter.py b/tests/test_parameter.py index 8e85eda..4786e12 100644 --- a/tests/test_parameter.py +++ b/tests/test_parameter.py @@ -27,43 +27,43 @@ from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text from mwparserfromhell.nodes.extras import Parameter -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext class TestParameter(TreeEqualityTestCase): """Test cases for the Parameter node extra.""" def test_unicode(self): """test Parameter.__unicode__()""" - node = Parameter(wrap([Text("1")]), wrap([Text("foo")]), showkey=False) + node = Parameter(wraptext("1"), wraptext("foo"), showkey=False) self.assertEqual("foo", str(node)) - node2 = Parameter(wrap([Text("foo")]), wrap([Text("bar")])) + node2 = Parameter(wraptext("foo"), wraptext("bar")) self.assertEqual("foo=bar", str(node2)) def test_name(self): """test getter/setter for the name attribute""" - name1 = wrap([Text("1")]) - name2 = wrap([Text("foobar")]) - node1 = Parameter(name1, wrap([Text("foobar")]), showkey=False) - node2 = Parameter(name2, wrap([Text("baz")])) + name1 = wraptext("1") + 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) node1.name = "héhehé" node2.name = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.name) - self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.name) + self.assertWikicodeEqual(wraptext("héhehé"), node1.name) + self.assertWikicodeEqual(wraptext("héhehé"), node2.name) def test_value(self): """test getter/setter for the value attribute""" - value = wrap([Text("bar")]) - node = Parameter(wrap([Text("foo")]), value) + value = wraptext("bar") + node = Parameter(wraptext("foo"), value) self.assertIs(value, node.value) node.value = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node.value) + self.assertWikicodeEqual(wraptext("héhehé"), node.value) def test_showkey(self): """test getter/setter for the showkey attribute""" - node1 = Parameter(wrap([Text("1")]), wrap([Text("foo")]), showkey=False) - node2 = Parameter(wrap([Text("foo")]), wrap([Text("bar")])) + node1 = Parameter(wraptext("1"), wraptext("foo"), showkey=False) + node2 = Parameter(wraptext("foo"), wraptext("bar")) self.assertFalse(node1.showkey) self.assertTrue(node2.showkey) node1.showkey = True diff --git a/tests/test_parser.py b/tests/test_parser.py index 9d2c969..ec5f065 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -26,10 +26,8 @@ import unittest from mwparserfromhell import parser from mwparserfromhell.nodes import Template, Text, Wikilink from mwparserfromhell.nodes.extras import Parameter -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext from .compat import range class TestParser(TreeEqualityTestCase): @@ -45,18 +43,17 @@ class TestParser(TreeEqualityTestCase): def test_parsing(self): """integration test for parsing overall""" text = "this is text; {{this|is=a|template={{with|[[links]]|in}}it}}" - wrap = lambda L: Wikicode(SmartList(L)) expected = wrap([ Text("this is text; "), - Template(wrap([Text("this")]), [ - Parameter(wrap([Text("is")]), wrap([Text("a")])), - Parameter(wrap([Text("template")]), wrap([ - Template(wrap([Text("with")]), [ - Parameter(wrap([Text("1")]), - wrap([Wikilink(wrap([Text("links")]))]), + Template(wraptext("this"), [ + Parameter(wraptext("is"), wraptext("a")), + Parameter(wraptext("template"), wrap([ + Template(wraptext("with"), [ + Parameter(wraptext("1"), + wrap([Wikilink(wraptext("links"))]), showkey=False), - Parameter(wrap([Text("2")]), - wrap([Text("in")]), showkey=False) + Parameter(wraptext("2"), + wraptext("in"), showkey=False) ]), Text("it") ])) diff --git a/tests/test_utils.py b/tests/test_utils.py index c088530..80a0e5e 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -24,33 +24,28 @@ from __future__ import unicode_literals import unittest from mwparserfromhell.nodes import Template, Text -from mwparserfromhell.smart_list import SmartList from mwparserfromhell.utils import parse_anything -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext class TestUtils(TreeEqualityTestCase): """Tests for the utils module, which provides parse_anything().""" def test_parse_anything_valid(self): """tests for valid input to utils.parse_anything()""" - wrap = lambda L: Wikicode(SmartList(L)) - textify = lambda L: wrap([Text(item) for item in L]) tests = [ - (wrap([Text("foobar")]), textify(["foobar"])), - (Template(wrap([Text("spam")])), - wrap([Template(textify(["spam"]))])), - ("fóóbar", textify(["fóóbar"])), - (b"foob\xc3\xa1r", textify(["foobár"])), - (123, textify(["123"])), - (True, textify(["True"])), + (wraptext("foobar"), wraptext("foobar")), + (Template(wraptext("spam")), wrap([Template(wraptext("spam"))])), + ("fóóbar", wraptext("fóóbar")), + (b"foob\xc3\xa1r", wraptext("foobár")), + (123, wraptext("123")), + (True, wraptext("True")), (None, wrap([])), ([Text("foo"), Text("bar"), Text("baz")], - textify(["foo", "bar", "baz"])), - ([wrap([Text("foo")]), Text("bar"), "baz", 123, 456], - textify(["foo", "bar", "baz", "123", "456"])), - ([[[([[((("foo",),),)], "bar"],)]]], textify(["foo", "bar"])) + wraptext("foo", "bar", "baz")), + ([wraptext("foo"), Text("bar"), "baz", 123, 456], + wraptext("foo", "bar", "baz", "123", "456")), + ([[[([[((("foo",),),)], "bar"],)]]], wraptext("foo", "bar")) ] for test, valid in tests: self.assertWikicodeEqual(valid, parse_anything(test)) diff --git a/tests/test_wikilink.py b/tests/test_wikilink.py index d4319c1..7851032 100644 --- a/tests/test_wikilink.py +++ b/tests/test_wikilink.py @@ -26,16 +26,16 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text, Wikilink -from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext class TestWikilink(TreeEqualityTestCase): """Test cases for the Wikilink node.""" def test_unicode(self): """test Wikilink.__unicode__()""" - node = Wikilink(wrap([Text("foobar")])) + node = Wikilink(wraptext("foobar")) self.assertEqual("[[foobar]]", str(node)) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node2 = Wikilink(wraptext("foo"), wraptext("bar")) self.assertEqual("[[foo|bar]]", str(node2)) def test_iternodes(self): @@ -57,8 +57,8 @@ class TestWikilink(TreeEqualityTestCase): def test_strip(self): """test Wikilink.__strip__()""" - node = Wikilink(wrap([Text("foobar")])) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node = Wikilink(wraptext("foobar")) + node2 = Wikilink(wraptext("foo"), wraptext("bar")) for a in (True, False): for b in (True, False): self.assertEqual("foobar", node.__strip__(a, b)) @@ -70,8 +70,8 @@ class TestWikilink(TreeEqualityTestCase): getter, marker = object(), object() get = lambda code: output.append((getter, code)) mark = lambda: output.append(marker) - node1 = Wikilink(wrap([Text("foobar")])) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node1 = Wikilink(wraptext("foobar")) + node2 = Wikilink(wraptext("foo"), wraptext("bar")) node1.__showtree__(output.append, get, mark) node2.__showtree__(output.append, get, mark) valid = [ @@ -81,26 +81,26 @@ class TestWikilink(TreeEqualityTestCase): def test_title(self): """test getter/setter for the title attribute""" - title = wrap([Text("foobar")]) + title = wraptext("foobar") node1 = Wikilink(title) - node2 = Wikilink(title, wrap([Text("baz")])) + node2 = Wikilink(title, wraptext("baz")) self.assertIs(title, node1.title) self.assertIs(title, node2.title) node1.title = "héhehé" node2.title = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.title) - self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.title) + self.assertWikicodeEqual(wraptext("héhehé"), node1.title) + self.assertWikicodeEqual(wraptext("héhehé"), node2.title) def test_text(self): """test getter/setter for the text attribute""" - text = wrap([Text("baz")]) - node1 = Wikilink(wrap([Text("foobar")])) - node2 = Wikilink(wrap([Text("foobar")]), text) + text = wraptext("baz") + node1 = Wikilink(wraptext("foobar")) + node2 = Wikilink(wraptext("foobar"), text) self.assertIs(None, node1.text) self.assertIs(text, node2.text) node1.text = "buzz" node2.text = None - self.assertWikicodeEqual(wrap([Text("buzz")]), node1.text) + self.assertWikicodeEqual(wraptext("buzz"), node1.text) self.assertIs(None, node2.text) if __name__ == "__main__":