genshi/genshi-test: genshi/template/tests/directives.py comparison

comparison genshi/template/tests/directives.py @ 902:09cc3627654c experimental-inline

Sync `experimental/inline` branch with [source:trunk@1126].

author	cmlenz
date	Fri, 23 Apr 2010 21:08:26 +0000
parents	1837f39efd6f
children

comparison

equal deleted inserted replaced

-:de82830f8816
+:09cc3627654c
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2006-2008 Edgewall Software
+# Copyright (C) 2006-2010 Edgewall Software
 # All rights reserved.
 #
 # This software is licensed as described in the file COPYING, which
 # you should have received as part of this distribution. The terms
 # are also available at http://genshi.edgewall.org/wiki/License.
 # This software consists of voluntary contributions made by many
 # individuals. For the exact contribution history, see the revision
 # history and logs, available at http://genshi.edgewall.org/log/.
 import doctest
+import re
 import sys
 import unittest
 from genshi.template import directives, MarkupTemplate, TextTemplate, \
 TemplateRuntimeError, TemplateSyntaxError
 <elem py:for="item in items" py:attrs="item"/>
 </doc>""")
 items = [{'id': 1, 'class': 'foo'}, {'id': 2, 'class': 'bar'}]
 self.assertEqual("""<doc>
 <elem id="1" class="foo"/><elem id="2" class="bar"/>
-</doc>""", str(tmpl.generate(items=items)))
+</doc>""", tmpl.generate(items=items).render(encoding=None))
 def test_update_existing_attr(self):
 """
 Verify that an attribute value that evaluates to `None` removes an
 existing attribute of that name.
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <elem class="foo" py:attrs="{'class': 'bar'}"/>
 </doc>""")
 self.assertEqual("""<doc>
 <elem class="bar"/>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_remove_existing_attr(self):
 """
 Verify that an attribute value that evaluates to `None` removes an
 existing attribute of that name.
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <elem class="foo" py:attrs="{'class': None}"/>
 </doc>""")
 self.assertEqual("""<doc>
 <elem/>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 class ChooseDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:choose` template directive and the complementary
 directives `py:when` and `py:otherwise`."""
 <span py:when="2 == 2">2</span>
 <span py:when="3 == 3">3</span>
 </div>""")
 self.assertEqual("""<div>
 <span>1</span>
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 def test_otherwise(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/" py:choose="">
 <span py:when="False">hidden</span>
 <span py:otherwise="">hello</span>
 </div>""")
 self.assertEqual("""<div>
 <span>hello</span>
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 def test_nesting(self):
 """
 Verify that `py:choose` blocks can be nested:
 """
 <div>
 <div>
 <span>3</span>
 </div>
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_complex_nesting(self):
 """
 Verify more complex nesting.
 """
 <div>
 <div>
 <span>OK</span>
 </div>
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_complex_nesting_otherwise(self):
 """
 Verify more complex nesting using otherwise.
 """
 <div>
 <div>
 <span>OK</span>
 </div>
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_when_with_strip(self):
 """
 Verify that a when directive with a strip directive actually strips of
 the outer element.
 <span py:otherwise="">foo</span>
 </div>
 </doc>""")
 self.assertEqual("""<doc>
 <span>foo</span>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_when_outside_choose(self):
 """
 Verify that a `when` directive outside of a `choose` directive is
 reported as an error.
 <py:when>foo</py:when>
 </div>
 </doc>""")
 self.assertEqual("""<doc>
 foo
-</doc>""", str(tmpl.generate(foo='Yeah')))
+</doc>""", tmpl.generate(foo='Yeah').render(encoding=None))
 def test_otherwise_without_test(self):
 """
 Verify that an `otherwise` directive can be used without a `test`
 attribute.
 <py:otherwise>foo</py:otherwise>
 </div>
 </doc>""")
 self.assertEqual("""<doc>
 foo
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_as_element(self):
 """
 Verify that the directive can also be used as an element.
 """
 <py:when test="3 == 3">3</py:when>
 </py:choose>
 </doc>""")
 self.assertEqual("""<doc>
 1
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_in_text_template(self):
 """
 Verify that the directive works as expected in a text template.
 """
 #end
 #when 3 == 3
 3
 #end
 #end""")
-self.assertEqual("""            1\n""", str(tmpl.generate()))
+self.assertEqual("""            1\n""",
+tmpl.generate().render(encoding=None))
 class DefDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:def` template directive."""
 </div>
 ${echo('foo')}
 </doc>""")
 self.assertEqual("""<doc>
 <b>foo</b>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_exec_in_replace(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <p py:def="echo(greeting, name='world')" class="message">
 ${greeting}, ${name}!
 </div>""")
 self.assertEqual("""<div>
 <p class="message">
 hello, world!
 </p>
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 def test_as_element(self):
 """
 Verify that the directive can also be used as an element.
 """
 </py:def>
 ${echo('foo')}
 </doc>""")
 self.assertEqual("""<doc>
 <b>foo</b>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_nested_defs(self):
 """
 Verify that a template function defined inside a conditional block can
 be called from outside that block.
 </py:if>
 ${echo('foo')}
 </doc>""")
 self.assertEqual("""<doc>
 <strong>foo</strong>
-</doc>""", str(tmpl.generate(semantic=True)))
+</doc>""", tmpl.generate(semantic=True).render(encoding=None))
 def test_function_with_default_arg(self):
 """
 Verify that keyword arguments work with `py:def` directives.
 """
 <b py:def="echo(what, bold=False)" py:strip="not bold">${what}</b>
 ${echo('foo')}
 </doc>""")
 self.assertEqual("""<doc>
 foo
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_invocation_in_attribute(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <py:def function="echo(what)">${what or 'something'}</py:def>
 <p class="${echo('foo')}">bar</p>
 </doc>""")
 self.assertEqual("""<doc>
 <p class="foo">bar</p>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_invocation_in_attribute_none(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <py:def function="echo()">${None}</py:def>
 <p class="${echo()}">bar</p>
 </doc>""")
 self.assertEqual("""<doc>
 <p>bar</p>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_function_raising_typeerror(self):
 def badfunc():
 raise TypeError
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <title>${maketitle(True)}</title>
 </head>
 </doc>""")
 self.assertEqual("""<doc>
 <head><title>True</title></head>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_in_text_template(self):
 """
 Verify that the directive works as expected in a text template.
 """
 ${echo('Hi', name='you')}
 """)
 self.assertEqual("""
 Hi, you!
-""", str(tmpl.generate()))
+""", tmpl.generate().render(encoding=None))
 def test_function_with_star_args(self):
 """
 Verify that a named template function using "star arguments" works as
 expected.
 self.assertEqual("""<doc>
 <div>
 [1, 2]
 {'a': 3, 'b': 4}
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 class ForDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:for` template directive."""
 <b>1</b>
 <b>2</b>
 <b>3</b>
 <b>4</b>
 <b>5</b>
-</doc>""", str(tmpl.generate(items=range(1, 6))))
+</doc>""", tmpl.generate(items=range(1, 6)).render(encoding=None))
 def test_as_element(self):
 """
 Verify that the directive can also be used as an element.
 """
 <b>1</b>
 <b>2</b>
 <b>3</b>
 <b>4</b>
 <b>5</b>
-</doc>""", str(tmpl.generate(items=range(1, 6))))
+</doc>""", tmpl.generate(items=range(1, 6)).render(encoding=None))
 def test_multi_assignment(self):
 """
 Verify that assignment to tuples works correctly.
 """
 </py:for>
 </doc>""")
 self.assertEqual("""<doc>
 <p>key=a, value=1</p>
 <p>key=b, value=2</p>
-</doc>""", str(tmpl.generate(items=dict(a=1, b=2).items())))
+</doc>""", tmpl.generate(items=dict(a=1, b=2).items())
+.render(encoding=None))
 def test_nested_assignment(self):
 """
 Verify that assignment to nested tuples works correctly.
 """
 </py:for>
 </doc>""")
 self.assertEqual("""<doc>
 <p>0: key=a, value=1</p>
 <p>1: key=b, value=2</p>
-</doc>""", str(tmpl.generate(items=enumerate(dict(a=1, b=2).items()))))
+</doc>""", tmpl.generate(items=enumerate(dict(a=1, b=2).items()))
+.render(encoding=None))
 def test_not_iterable(self):
 """
 Verify that assignment to nested tuples works correctly.
 """
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <b py:if="foo" py:strip="">${bar}</b>
 </doc>""")
 self.assertEqual("""<doc>
 Hello
-</doc>""", str(tmpl.generate(foo=True, bar='Hello')))
+</doc>""", tmpl.generate(foo=True, bar='Hello').render(encoding=None))
 def test_as_element(self):
 """
 Verify that the directive can also be used as an element.
 """
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <py:if test="foo">${bar}</py:if>
 </doc>""")
 self.assertEqual("""<doc>
 Hello
-</doc>""", str(tmpl.generate(foo=True, bar='Hello')))
+</doc>""", tmpl.generate(foo=True, bar='Hello').render(encoding=None))
 class MatchDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:match` template directive."""
 </elem>
 <elem>Hey Joe</elem>
 </doc>""")
 self.assertEqual("""<doc>
 <div class="elem">Hey Joe</div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_without_strip(self):
 """
 Verify that a match template can produce the same kind of element that
 it matched without entering an infinite recursion.
 </doc>""")
 self.assertEqual("""<doc>
 <elem>
 <div class="elem">Hey Joe</div>
 </elem>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_as_element(self):
 """
 Verify that the directive can also be used as an element.
 """
 </py:match>
 <elem>Hey Joe</elem>
 </doc>""")
 self.assertEqual("""<doc>
 <div class="elem">Hey Joe</div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_recursive_match_1(self):
 """
 Match directives are applied recursively, meaning that they are also
 applied to any content they may have produced themselves:
 </div>
 </elem>
 </subelem>
 </div>
 </elem>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_recursive_match_2(self):
 """
 When two or more match templates match the same element and also
 themselves output the element they match, avoiding recursion is even
 self.assertEqual("""<html>
 <body>
 <div id="header"/><h1>Foo</h1>
 <div id="footer"/>
 </body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_recursive_match_3(self):
 tmpl = MarkupTemplate("""<test xmlns:py="http://genshi.edgewall.org/">
 <py:match path="b[@type='bullet']">
 <bullet>${select('*|text()')}</bullet>
 """)
 self.assertEqual("""<test>
 <generic>
 <ul><bullet>1</bullet><bullet>2</bullet></ul>
 </generic>
-</test>""", str(tmpl.generate()))
+</test>""", tmpl.generate().render(encoding=None))
 def test_not_match_self(self):
 """
 See http://genshi.edgewall.org/ticket/77
 """
 self.assertEqual("""<html xmlns="http://www.w3.org/1999/xhtml">
 <body><h1>
 Hello!
 Goodbye!
 </h1></body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_select_text_in_element(self):
 """
 See http://genshi.edgewall.org/ticket/77#comment:1
 """
 <text>
 Hello!
 </text>
 Goodbye!
 </h1></body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_select_all_attrs(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <div py:match="elem" py:attrs="select('@*')">
 ${select('text()')}
 </doc>""")
 self.assertEqual("""<doc>
 <div id="joe">
 Hey Joe
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_select_all_attrs_empty(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <div py:match="elem" py:attrs="select('@*')">
 ${select('text()')}
 </doc>""")
 self.assertEqual("""<doc>
 <div>
 Hey Joe
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_select_all_attrs_in_body(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <div py:match="elem">
 Hey ${select('text()')} ${select('@*')}
 </doc>""")
 self.assertEqual("""<doc>
 <div>
 Hey Joe Cool
 </div>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_def_in_match(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <py:def function="maketitle(test)"><b py:replace="test" /></py:def>
 <head py:match="head">${select('*')}</head>
 <head><title>${maketitle(True)}</title></head>
 </doc>""")
 self.assertEqual("""<doc>
 <head><title>True</title></head>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
 def test_match_with_xpath_variable(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <span py:match="*[name()=$tagname]">
 Hello ${select('@name')}
 </div>""")
 self.assertEqual("""<div>
 <span>
 Hello Dude
 </span>
-</div>""", str(tmpl.generate(tagname='greeting')))
+</div>""", tmpl.generate(tagname='greeting').render(encoding=None))
 self.assertEqual("""<div>
 <greeting name="Dude"/>
-</div>""", str(tmpl.generate(tagname='sayhello')))
+</div>""", tmpl.generate(tagname='sayhello').render(encoding=None))
 def test_content_directive_in_match(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <div py:match="foo">I said <q py:content="select('text()')">something</q>.</div>
 <foo>bar</foo>
 </html>""")
 self.assertEqual("""<html>
 <div>I said <q>bar</q>.</div>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_cascaded_matches(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <body py:match="body">${select('*')}</body>
 <head py:match="head">${select('title')}</head>
 <body><h2>Are you ready to mark up?</h2></body>
 </html>""")
 self.assertEqual("""<html>
 <head><title>Welcome to Markup</title></head>
 <body><h2>Are you ready to mark up?</h2><hr/></body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_multiple_matches(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <input py:match="form//input" py:attrs="select('@*')"
 value="${values[str(select('@name'))]}" />
 <input value="3" type="text" name="hello_3"/>
 </p><p>
 <label>Hello_4</label>
 <input value="4" type="text" name="hello_4"/>
 </p></form>
-</html>""", str(tmpl.generate(fields=fields, values=values)))
+</html>""", tmpl.generate(fields=fields, values=values)
+.render(encoding=None))
 def test_namespace_context(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
 xmlns:x="http://www.example.org/">
 <div py:match="x:foo">Foo</div>
 </html>""")
 # FIXME: there should be a way to strip out unwanted/unused namespaces,
 #        such as the "x" in this example
 self.assertEqual("""<html xmlns:x="http://www.example.org/">
 <div>Foo</div>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_match_with_position_predicate(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <p py:match="body/p[1]" class="first">${select('*|text()')}</p>
 <body>
 self.assertEqual("""<html>
 <body>
 <p class="first">Foo</p>
 <p>Bar</p>
 </body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_match_with_closure(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <p py:match="body//p" class="para">${select('*|text()')}</p>
 <body>
 self.assertEqual("""<html>
 <body>
 <p class="para">Foo</p>
 <div><p class="para">Bar</p></div>
 </body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_match_without_closure(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <p py:match="body/p" class="para">${select('*|text()')}</p>
 <body>
 self.assertEqual("""<html>
 <body>
 <p class="para">Foo</p>
 <div><p>Bar</p></div>
 </body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_match_with_once_attribute(self):
 tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
 <py:match path="body" once="true"><body>
 <div id="wrap">
 </div>
 </body>
 <body>
 <p>Bar</p>
 </body>
-</html>""", str(tmpl.generate()))
+</html>""", tmpl.generate().render(encoding=None))
 def test_match_with_recursive_attribute(self):
 tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
 <py:match path="elem" recursive="false"><elem>
 <div class="elem">
 <subelem>
 <elem/>
 </subelem>
 </div>
 </elem>
-</doc>""", str(tmpl.generate()))
+</doc>""", tmpl.generate().render(encoding=None))
+# See http://genshi.edgewall.org/ticket/254/
+def test_triple_match_produces_no_duplicate_items(self):
+tmpl = MarkupTemplate("""<doc xmlns:py="http://genshi.edgewall.org/">
+<div py:match="div[@id='content']" py:attrs="select('@*')" once="true">
+<ul id="tabbed_pane" />
+${select('*')}
+</div>
+<body py:match="body" once="true" buffer="false">
+${select('*|text()')}
+</body>
+<body py:match="body" once="true" buffer="false">
+${select('*|text()')}
+</body>
+<body>
+<div id="content">
+<h1>Ticket X</h1>
+</div>
+</body>
+</doc>""")
+output = tmpl.generate().render('xhtml', doctype='xhtml')
+matches = re.findall("tabbed_pane", output)
+self.assertNotEqual(None, matches)
+self.assertEqual(1, len(matches))
+def test_match_multiple_times1(self):
+# See http://genshi.edgewall.org/ticket/370
+tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
+<py:match path="body[@id='content']/h2" />
+<head py:match="head" />
+<head py:match="head" />
+<head />
+<body />
+</html>""")
+self.assertEqual("""<html>
+<head/>
+<body/>
+</html>""", tmpl.generate().render())
+def test_match_multiple_times2(self):
+# See http://genshi.edgewall.org/ticket/370
+tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/">
+<py:match path="body/div[@id='properties']" />
+<head py:match="head" />
+<head py:match="head" />
+<head/>
+<body>
+<div id="properties">Foo</div>
+</body>
+</html>""")
+self.assertEqual("""<html>
+<head/>
+<body>
+</body>
+</html>""", tmpl.generate().render())
 # FIXME
 #def test_match_after_step(self):
 #    tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 #      <span py:match="div/greeting">
 #    </div>""")
 #    self.assertEqual("""<div>
 #      <span>
 #        Hello Dude
 #      </span>
-#    </div>""", str(tmpl.generate()))
+#    </div>""", tmpl.generate().render(encoding=None))
 class ContentDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:content` template directive."""
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:replace value="title" />
 </div>""", filename='test.html')
 self.assertEqual("""<div>
 Test
-</div>""", str(tmpl.generate(title='Test')))
+</div>""", tmpl.generate(title='Test').render(encoding=None))
 class StripDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:strip` template directive."""
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <div py:strip="False"><b>foo</b></div>
 </div>""")
 self.assertEqual("""<div>
 <div><b>foo</b></div>
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 def test_strip_empty(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <div py:strip=""><b>foo</b></div>
 </div>""")
 self.assertEqual("""<div>
 <b>foo</b>
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 class WithDirectiveTestCase(unittest.TestCase):
 """Tests for the `py:with` template directive."""
 </div>""")
 self.assertEqual("""<div>
 42
 84
 42
-</div>""", str(tmpl.generate(x=42)))
+</div>""", tmpl.generate(x=42).render(encoding=None))
 def test_as_element(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:with vars="x = x * 2">${x}</py:with>
 </div>""")
 self.assertEqual("""<div>
 84
-</div>""", str(tmpl.generate(x=42)))
+</div>""", tmpl.generate(x=42).render(encoding=None))
 def test_multiple_vars_same_name(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:with vars="
 foo = 'bar';
 $foo
 </py:with>
 </div>""")
 self.assertEqual("""<div>
 baz
-</div>""", str(tmpl.generate(x=42)))
+</div>""", tmpl.generate(x=42).render(encoding=None))
 def test_multiple_vars_single_assignment(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:with vars="x = y = z = 1">${x} ${y} ${z}</py:with>
 </div>""")
 self.assertEqual("""<div>
 1 1 1
-</div>""", str(tmpl.generate(x=42)))
+</div>""", tmpl.generate(x=42).render(encoding=None))
 def test_nested_vars_single_assignment(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:with vars="x, (y, z) = (1, (2, 3))">${x} ${y} ${z}</py:with>
 </div>""")
 self.assertEqual("""<div>
 1 2 3
-</div>""", str(tmpl.generate(x=42)))
+</div>""", tmpl.generate(x=42).render(encoding=None))
 def test_multiple_vars_trailing_semicolon(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:with vars="x = x * 2; y = x / 2;">${x} ${y}</py:with>
 </div>""")
 self.assertEqual("""<div>
 84 42
-</div>""", str(tmpl.generate(x=42)))
+</div>""", tmpl.generate(x=42).render(encoding=None))
 def test_semicolon_escape(self):
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <py:with vars="x = 'here is a semicolon: ;'; y = 'here are two semicolons: ;;' ;">
 ${x}
 </py:with>
 </div>""")
 self.assertEqual("""<div>
 here is a semicolon: ;
 here are two semicolons: ;;
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 def test_ast_transformation(self):
 """
 Verify that the usual template expression AST transformations are
 applied despite the code being compiled to a `Suite` object.
 </div>""")
 self.assertEqual("""<div>
 <span>
 42
 </span>
-</div>""", str(tmpl.generate(foo={'bar': 42})))
+</div>""", tmpl.generate(foo={'bar': 42}).render(encoding=None))
 def test_unicode_expr(self):
-tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
+tmpl = MarkupTemplate(u"""<div xmlns:py="http://genshi.edgewall.org/">
 <span py:with="weeks=(u'一', u'二', u'三', u'四', u'五', u'六', u'日')">
 $weeks
 </span>
 </div>""")
-self.assertEqual("""<div>
+self.assertEqual(u"""<div>
 <span>
 一二三四五六日
 </span>
-</div>""", str(tmpl.generate()))
+</div>""", tmpl.generate().render(encoding=None))
 def test_with_empty_value(self):
 """
 Verify that an empty py:with works (useless, but legal)
 """
 tmpl = MarkupTemplate("""<div xmlns:py="http://genshi.edgewall.org/">
 <span py:with="">Text</span></div>""")
 self.assertEqual("""<div>
-<span>Text</span></div>""", str(tmpl.generate()))
+<span>Text</span></div>""", tmpl.generate().render(encoding=None))
 def suite():
 suite = unittest.TestSuite()
 suite.addTest(doctest.DocTestSuite(directives))

Mercurial > genshi > genshi-test

comparison genshi/template/tests/directives.py @ 902:09cc3627654c experimental-inline