def test_strip(self):
"""test Argument.__strip__()"""
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))
self.assertEqual("bar", node2.__strip__(a, b))
def test_default(self):
"""test getter/setter for the default attribute"""
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(wraptext("buzz"), node1.default)
self.assertIs(None, node2.default)
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)
node1.name = "héhehé"
node2.name = "héhehé"
self.assertWikicodeEqual(wraptext("héhehé"), node1.name)
self.assertWikicodeEqual(wraptext("héhehé"), node2.name)
def test_children(self):
"""test Argument.__children__()"""
node1 = Argument(wraptext("foobar"))
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)
def test_iternodes(self):
"""test Argument.__iternodes__()"""
node1n1 = Text("foobar")
node2n1, node2n2, node2n3 = Text("foo"), Text("bar"), Text("baz")
node1 = Argument(wrap([node1n1]))
node2 = Argument(wrap([node2n1]), wrap([node2n2, node2n3]))
gen1 = node1.__iternodes__(getnodes)
gen2 = node2.__iternodes__(getnodes)
self.assertEqual((None, node1), next(gen1))
self.assertEqual((None, node2), next(gen2))
self.assertEqual((node1.name, node1n1), next(gen1))
self.assertEqual((node2.name, node2n1), next(gen2))
self.assertEqual((node2.default, node2n2), next(gen2))
self.assertEqual((node2.default, node2n3), next(gen2))
self.assertRaises(StopIteration, next, gen1)
self.assertRaises(StopIteration, next, gen2)
def test_showtree(self):
"""test Argument.__showtree__()"""
output = []
getter, marker = object(), object()
get = lambda code: output.append((getter, code))
mark = lambda: output.append(marker)
node1 = Argument(wraptext("foobar"))
node2 = Argument(wraptext("foo"), wraptext("bar"))
node1.__showtree__(output.append, get, mark)
node2.__showtree__(output.append, get, mark)
valid = [
"{{{", (getter, node1.name), "}}}", "{{{", (getter, node2.name),
" | ", marker, (getter, node2.default), "}}}"]
self.assertEqual(valid, output)
def test_integration2(self):
"""an even more audacious test for building a horrible wikicode mess"""
# {{a|b|{{c|[[d]]{{{e}}}}}}}[[f|{{{g}}}<!--h-->]]{{i|j= }}
test = [
tokens.TemplateOpen(),
tokens.Text(text="a"),
tokens.TemplateParamSeparator(),
tokens.Text(text="b"),
tokens.TemplateParamSeparator(),
tokens.TemplateOpen(),
tokens.Text(text="c"),
tokens.TemplateParamSeparator(),
tokens.WikilinkOpen(),
tokens.Text(text="d"),
tokens.WikilinkClose(),
tokens.ArgumentOpen(),
tokens.Text(text="e"),
tokens.ArgumentClose(),
tokens.TemplateClose(),
tokens.TemplateClose(),
tokens.WikilinkOpen(),
tokens.Text(text="f"),
tokens.WikilinkSeparator(),
tokens.ArgumentOpen(),
tokens.Text(text="g"),
tokens.ArgumentClose(),
tokens.CommentStart(),
tokens.Text(text="h"),
tokens.CommentEnd(),
tokens.WikilinkClose(),
tokens.TemplateOpen(),
tokens.Text(text="i"),
tokens.TemplateParamSeparator(),
tokens.Text(text="j"),
tokens.TemplateParamEquals(),
tokens.HTMLEntityStart(),
tokens.Text(text="nbsp"),
tokens.HTMLEntityEnd(),
tokens.TemplateClose()
]
valid = wrap([
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))
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__())
def test_unicode(self):
"""test Argument.__unicode__()"""
node = Argument(wraptext("foobar"))
self.assertEqual("{{{foobar}}}", str(node))
node2 = Argument(wraptext("foo"), wraptext("bar"))
self.assertEqual("{{{foo|bar}}}", str(node2))
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__())
