[ZPT] CVS: Packages/TAL - test_htmltalparser.py:1.19

fred@digicool.com fred@digicool.com
Thu, 7 Jun 2001 14:04:34 -0400 (EDT)


Update of /cvs-repository/Packages/TAL/tests
In directory korak.digicool.com:/tmp/cvs-serv16118

Modified Files:
	test_htmltalparser.py 
Log Message:

Update all the expected bytecode to conform to the new format.



--- Updated File test_htmltalparser.py in package Packages/TAL --
--- test_htmltalparser.py	2001/05/18 01:24:05	1.18
+++ test_htmltalparser.py	2001/06/07 18:04:33	1.19
@@ -7,6 +7,8 @@
 import utils
 import unittest
 
+from string import rfind
+
 from TAL import HTMLTALParser
 from TAL.TALDefs import TAL_VERSION, TALError, METALError
 
@@ -15,14 +17,18 @@
 
     prologue = ""
     epilogue = ""
-    initial_program = [('version', TAL_VERSION), ('mode', 'html')]
+    initial_program = [('version', (TAL_VERSION,)), ('mode', ('html',))]
     final_program = []
 
     def _merge(self, p1, p2):
-        if p1 and p2 and p1[-1][0] == 'rawtext' and p2[0][0] == 'rawtext':
-            return p1[:-1] + [('rawtext', p1[-1][1] + p2[0][1])] + p2[1:]
-        else:
-            return p1+p2
+        if p1 and p2:
+            op1, args1 = p1[-1]
+            op2, args2 = p2[0]
+            if op1[:7] == 'rawtext' and op2[:7] == 'rawtext':
+                return (p1[:-1]
+                        + [rawtext(args1[0] + args2[0])]
+                        + p2[1:])
+        return p1+p2
 
     def _run_check(self, source, program, macros={}):
         parser = HTMLTALParser.HTMLTALParser()
@@ -30,8 +36,12 @@
         got_program, got_macros = parser.getCode()
         program = self._merge(self.initial_program, program)
         program = self._merge(program, self.final_program)
-        self.assert_(got_program == program, got_program)
-        self.assert_(got_macros == macros, got_macros)
+        self.assert_(got_program == program,
+                     "Program:\n" + pprint.pformat(got_program)
+                     + "\nExpaected:\n" + pprint.pformat(program))
+        self.assert_(got_macros == macros,
+                     "Macros:\n" + pprint.pformat(got_macros)
+                     + "\nExpaected:\n" + pprint.pformat(macros))
 
     def _get_check(self, source, program=[], macros={}):
         parser = HTMLTALParser.HTMLTALParser()
@@ -47,34 +57,42 @@
         self.assertRaises(exc, parse)
 
 
+def rawtext(s):
+    """Compile raw text to the appropriate instruction."""
+    if "\n" in s:
+        return ("rawtextColumn", (s, len(s) - (rfind(s, "\n") + 1)))
+    else:
+        return ("rawtextOffset", (s, len(s)))
+
+
 class HTMLTALParserTestCases(TestCaseBase):
 
     def check_code_simple_identity(self):
         self._run_check("""<html a='b' b="c" c=d><title>My Title</html>""", [
-            ('rawtext', '<html a="b" b="c" c="d">'
-                        '<title>My Title</title></html>'),
+            rawtext('<html a="b" b="c" c="d">'
+                    '<title>My Title</title></html>'),
             ])
 
     def check_code_implied_list_closings(self):
         self._run_check("""<ul><li><p><p><li></ul>""", [
-            ('rawtext', '<ul><li><p></p><p></p></li><li></li></ul>'),
+            rawtext('<ul><li><p></p><p></p></li><li></li></ul>'),
             ])
         self._run_check("""<dl><dt><dt><dd><dd><ol><li><li></ol></dl>""", [
-            ('rawtext', '<dl><dt></dt><dt></dt><dd></dd>'
-                        '<dd><ol><li></li><li></li></ol></dd></dl>'),
+            rawtext('<dl><dt></dt><dt></dt><dd></dd>'
+                    '<dd><ol><li></li><li></li></ol></dd></dl>'),
             ])
 
     def check_code_implied_table_closings(self):
         self._run_check("""<p>text <table><tr><th>head\t<tr><td>cell\t"""
                         """<table><tr><td>cell \n \t \n<tr>""", [
-            ('rawtext', '<p>text</p> <table><tr><th>head</th>'
-                        '</tr>\t<tr><td>cell\t<table><tr><td>cell</td>'
-                        '</tr> \n \t \n<tr></tr></table></td></tr></table>'),
+            rawtext('<p>text</p> <table><tr><th>head</th>'
+                    '</tr>\t<tr><td>cell\t<table><tr><td>cell</td>'
+                    '</tr> \n \t \n<tr></tr></table></td></tr></table>'),
             ])
         self._run_check("""<table><tr><td>cell """
                         """<table><tr><td>cell </table></table>""", [
-            ('rawtext', '<table><tr><td>cell <table><tr><td>cell</td></tr>'
-                        ' </table></td></tr></table>'),
+            rawtext('<table><tr><td>cell <table><tr><td>cell</td></tr>'
+                    ' </table></td></tr></table>'),
             ])
 
     def check_code_bad_nesting(self):
@@ -84,7 +102,7 @@
 
     def check_code_attr_syntax(self):
         output = [
-            ('rawtext', '<a b="v" c="v" d="v" e></a>'),
+            rawtext('<a b="v" c="v" d="v" e></a>'),
             ]
         self._run_check("""<a b='v' c="v" d=v e>""", output)
         self._run_check("""<a  b = 'v' c = "v" d = v e>""", output)
@@ -94,40 +112,39 @@
     def check_code_attr_values(self):
         self._run_check(
             """<a b='xxx\n\txxx' c="yyy\t\nyyy" d='\txyz\n'>""", [
-            ('rawtext',
-             '<a b="xxx\n\txxx" c="yyy\t\nyyy" d="\txyz\n"></a>')])
+            rawtext('<a b="xxx\n\txxx" c="yyy\t\nyyy" d="\txyz\n"></a>')])
         self._run_check("""<a b='' c="">""", [
-            ('rawtext', '<a b="" c=""></a>'),
+            rawtext('<a b="" c=""></a>'),
             ])
 
     def check_code_attr_entity_replacement(self):
         # we expect entities *not* to be replaced by HTLMParser!
         self._run_check("""<a b='&amp;&gt;&lt;&quot;&apos;'>""", [
-            ('rawtext', '<a b="&amp;&gt;&lt;&quot;\'"></a>'),
+            rawtext('<a b="&amp;&gt;&lt;&quot;\'"></a>'),
             ])
         self._run_check("""<a b='\"'>""", [
-            ('rawtext', '<a b="&quot;"></a>'),
+            rawtext('<a b="&quot;"></a>'),
             ])
         self._run_check("""<a b='&'>""", [
-            ('rawtext', '<a b="&amp;"></a>'),
+            rawtext('<a b="&amp;"></a>'),
             ])
         self._run_check("""<a b='<'>""", [
-            ('rawtext', '<a b="&lt;"></a>'),
+            rawtext('<a b="&lt;"></a>'),
             ])
 
     def check_code_attr_funky_names(self):
         self._run_check("""<a a.b='v' c:d=v e-f=v>""", [
-            ('rawtext', '<a a.b="v" c:d="v" e-f="v"></a>'),
+            rawtext('<a a.b="v" c:d="v" e-f="v"></a>'),
             ])
 
     def check_code_pcdata_entityref(self):
         self._run_check("""&nbsp;""", [
-            ('rawtext', '&nbsp;'),
+            rawtext('&nbsp;'),
             ])
 
     def check_code_short_endtags(self):
         self._run_check("""<html><img/></html>""", [
-            ('rawtext', '<html><img /></html>'),
+            rawtext('<html><img /></html>'),
             ])
 
 
@@ -138,36 +155,37 @@
 
     def check_define_macro(self):
         macro = self.initial_program + [
-            ('startTag', 'p', [('metal:define-macro', 'M', 'metal')]),
-            ('rawtext', 'booh</p>')]
+            ('startTag', ('p', [('metal:define-macro', 'M', 'metal')])),
+            rawtext('booh</p>'),
+            ]
         program = [
-            ('setPosition', (1, 0)),
-            ('defineMacro', 'M', macro),
+            ('setPosition', ((1, 0),)),
+            ('defineMacro', ('M', macro)),
             ]
         macros = {'M': macro}
         self._run_check('<p metal:define-macro="M">booh</p>', program, macros)
 
     def check_use_macro(self):
         self._run_check('<p metal:use-macro="M">booh</p>', [
-            ('setPosition', (1, 0)),
+            ('setPosition', ((1, 0),)),
             ('useMacro',
-             'M', '$M$', {},
-             [('startTag', 'p', [('metal:use-macro', 'M', 'metal')]),
-              ('rawtext', 'booh</p>')]),
+             ('M', '$M$', {},
+              [('startTag', ('p', [('metal:use-macro', 'M', 'metal')])),
+               rawtext('booh</p>')])),
             ])
 
     def check_define_slot(self):
         macro = self.initial_program + [
-            ('startTag', 'p', [('metal:define-macro', 'M', 'metal')]),
-            ('rawtext', 'foo'),
-            ('setPosition', (1, 29)),
-            ('defineSlot', 'S',
-             [('startTag', 'span', [('metal:define-slot', 'S', 'metal')]),
-              ('rawtext', 'spam</span>')]),
-            ('rawtext', 'bar</p>'),
+            ('startTag', ('p', [('metal:define-macro', 'M', 'metal')])),
+            rawtext('foo'),
+            ('setPosition', ((1, 29),)),
+            ('defineSlot', ('S',
+             [('startTag', ('span', [('metal:define-slot', 'S', 'metal')])),
+              rawtext('spam</span>')])),
+            rawtext('bar</p>'),
             ]
-        program = [('setPosition', (1, 0)),
-                   ('defineMacro', 'M', macro)]
+        program = [('setPosition', ((1, 0),)),
+                   ('defineMacro', ('M', macro))]
         macros = {'M': macro}
         self._run_check('<p metal:define-macro="M">foo'
                         '<span metal:define-slot="S">spam</span>bar</p>',
@@ -176,18 +194,19 @@
     def check_fill_slot(self):
         self._run_check('<p metal:use-macro="M">foo'
                         '<span metal:fill-slot="S">spam</span>bar</p>', [
-            ('setPosition', (1, 0)),
+            ('setPosition', ((1, 0),)),
             ('useMacro',
-             'M', '$M$',
-             {'S': [('startTag', 'span', [('metal:fill-slot', 'S', 'metal')]),
-                    ('rawtext', 'spam</span>')]},
-             [('startTag', 'p', [('metal:use-macro', 'M', 'metal')]),
-              ('rawtext', 'foo'),
-              ('setPosition', (1, 26)),
-              ('fillSlot', 'S',
-               [('startTag', 'span', [('metal:fill-slot', 'S', 'metal')]),
-                ('rawtext', 'spam</span>')]),
-              ('rawtext', 'bar</p>')]),
+             ('M', '$M$',
+              {'S': [('startTag', ('span',
+                                   [('metal:fill-slot', 'S', 'metal')])),
+                     rawtext('spam</span>')]},
+             [('startTag', ('p', [('metal:use-macro', 'M', 'metal')])),
+              rawtext('foo'),
+              ('setPosition', ((1, 26),)),
+              ('fillSlot', ('S',
+               [('startTag', ('span', [('metal:fill-slot', 'S', 'metal')])),
+                rawtext('spam</span>')])),
+              rawtext('bar</p>')])),
             ])
 
 
@@ -198,256 +217,259 @@
 
     def check_define_1(self):
         self._run_check("<p tal:define='xyzzy string:spam'></p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
-            ('rawAttrs', {'tal:define': 'xyzzy string:spam'}),
-            ('setLocal', 'xyzzy', '$string:spam$'),
-            ('startTag', 'p', [('tal:define', 'xyzzy string:spam', 'tal')]),
-            ('rawtext', '</p>'),
-            ('endScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
+            ('rawAttrs', ({'tal:define': 'xyzzy string:spam'},)),
+            ('setLocal', ('xyzzy', '$string:spam$')),
+            ('startTag', ('p', [('tal:define', 'xyzzy string:spam', 'tal')])),
+            rawtext('</p>'),
+            ('endScope', ()),
             ])
 
     def check_define_2(self):
         self._run_check("<p tal:define='local xyzzy string:spam'></p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
-            ('rawAttrs', {'tal:define': 'local xyzzy string:spam'}),
-            ('setLocal', 'xyzzy', '$string:spam$'),
-            ('startTag', 'p',
-             [('tal:define', 'local xyzzy string:spam', 'tal')]),
-            ('rawtext', '</p>'),
-            ('endScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
+            ('rawAttrs', ({'tal:define': 'local xyzzy string:spam'},)),
+            ('setLocal', ('xyzzy', '$string:spam$')),
+            ('startTag', ('p',
+             [('tal:define', 'local xyzzy string:spam', 'tal')])),
+            rawtext('</p>'),
+            ('endScope', ()),
             ])
 
     def check_define_3(self):
         self._run_check("<p tal:define='global xyzzy string:spam'></p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
-            ('rawAttrs', {'tal:define': 'global xyzzy string:spam'}),
-            ('setGlobal', 'xyzzy', '$string:spam$'),
-            ('startTag', 'p',
-             [('tal:define', 'global xyzzy string:spam', 'tal')]),
-            ('rawtext', '</p>'),
-            ('endScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
+            ('rawAttrs', ({'tal:define': 'global xyzzy string:spam'},)),
+            ('setGlobal', ('xyzzy', '$string:spam$')),
+            ('startTag', ('p',
+             [('tal:define', 'global xyzzy string:spam', 'tal')])),
+            rawtext('</p>'),
+            ('endScope', ()),
             ])
 
     def check_define_4(self):
         self._run_check("<p tal:define='x string:spam; y x'></p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
-            ('rawAttrs', {'tal:define': 'x string:spam; y x'}),
-            ('setLocal', 'x', '$string:spam$'),
-            ('setLocal', 'y', '$x$'),
-            ('startTag', 'p', [('tal:define', 'x string:spam; y x', 'tal')]),
-            ('rawtext', '</p>'),
-            ('endScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
+            ('rawAttrs', ({'tal:define': 'x string:spam; y x'},)),
+            ('setLocal', ('x', '$string:spam$')),
+            ('setLocal', ('y', '$x$')),
+            ('startTag', ('p', [('tal:define', 'x string:spam; y x', 'tal')])),
+            rawtext('</p>'),
+            ('endScope', ()),
             ])
 
     def check_define_5(self):
         self._run_check("<p tal:define='x string:;;;;; y x'></p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
-            ('rawAttrs', {'tal:define': 'x string:;;;;; y x'}),
-            ('setLocal', 'x', '$string:;;$'),
-            ('setLocal', 'y', '$x$'),
-            ('startTag', 'p', [('tal:define', 'x string:;;;;; y x', 'tal')]),
-            ('rawtext', '</p>'),
-            ('endScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
+            ('rawAttrs', ({'tal:define': 'x string:;;;;; y x'},)),
+            ('setLocal', ('x', '$string:;;$')),
+            ('setLocal', ('y', '$x$')),
+            ('startTag', ('p', [('tal:define', 'x string:;;;;; y x', 'tal')])),
+            rawtext('</p>'),
+            ('endScope', ()),
             ])
 
     def check_define_6(self):
         self._run_check(
             "<p tal:define='x string:spam; global y x; local z y'></p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
             ('rawAttrs',
-             {'tal:define': 'x string:spam; global y x; local z y'}),
-            ('setLocal', 'x', '$string:spam$'),
-            ('setGlobal', 'y', '$x$'),
-            ('setLocal', 'z', '$y$'),
-            ('startTag', 'p',
-             [('tal:define', 'x string:spam; global y x; local z y', 'tal')]),
-            ('rawtext', '</p>'),
-            ('endScope',),
+             ({'tal:define': 'x string:spam; global y x; local z y'},)),
+            ('setLocal', ('x', '$string:spam$')),
+            ('setGlobal', ('y', '$x$')),
+            ('setLocal', ('z', '$y$')),
+            ('startTag', ('p',
+             [('tal:define', 'x string:spam; global y x; local z y', 'tal')])),
+            rawtext('</p>'),
+            ('endScope', ()),
             ])
 
     def check_condition(self):
         self._run_check(
             "<p><span tal:condition='python:1'><b>foo</b></span></p>", [
-            ('rawtext', '<p>'),
-            ('setPosition', (1, 3)),
-            ('beginScope',),
-            ('rawAttrs', {'tal:condition': 'python:1'}),
-            ('condition', '$python:1$',
-             [('startTag', 'span', [('tal:condition', 'python:1', 'tal')]),
-              ('rawtext', '<b>foo</b></span>')]),
-            ('endScope',),
-            ('rawtext', '</p>'),
+            rawtext('<p>'),
+            ('setPosition', ((1, 3),)),
+            ('beginScope', ()),
+            ('rawAttrs', ({'tal:condition': 'python:1'},)),
+            ('condition', ('$python:1$',
+             [('startTag', ('span', [('tal:condition', 'python:1', 'tal')])),
+              rawtext('<b>foo</b></span>')])),
+            ('endScope', ()),
+            rawtext('</p>'),
             ])
 
     def check_content_1(self):
         self._run_check("<p tal:content='string:foo'>bar</p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:content': 'string:foo'}), 
-             ('startTag', 'p', [('tal:content', 'string:foo', 'tal')]),
-             ('insertText', '$string:foo$', [('rawtext', 'bar')]),
-             ('rawtext', '</p>'),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:content': 'string:foo'},)), 
+             ('startTag', ('p', [('tal:content', 'string:foo', 'tal')])),
+             ('insertText', ('$string:foo$', [rawtext('bar')])),
+             rawtext('</p>'),
+             ('endScope', ()),
              ])
 
     def check_content_2(self):
         self._run_check("<p tal:content='text string:foo'>bar</p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:content': 'text string:foo'}),
-             ('startTag', 'p', [('tal:content', 'text string:foo', 'tal')]),
-             ('insertText', '$string:foo$', [('rawtext', 'bar')]),
-             ('rawtext', '</p>'),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:content': 'text string:foo'},)),
+             ('startTag', ('p', [('tal:content', 'text string:foo', 'tal')])),
+             ('insertText', ('$string:foo$', [rawtext('bar')])),
+             rawtext('</p>'),
+             ('endScope', ()),
              ])
 
     def check_content_3(self):
         self._run_check("<p tal:content='structure string:<br>'>bar</p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:content': 'structure string:<br>'}),
-             ('startTag', 'p',
-              [('tal:content', 'structure string:<br>', 'tal')]),
-             ('insertStructure', '$string:<br>$', {}, [('rawtext', 'bar')]),
-             ('rawtext', '</p>'),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:content': 'structure string:<br>'},)),
+             ('startTag', ('p',
+              [('tal:content', 'structure string:<br>', 'tal')])),
+             ('insertStructure',
+              ('$string:<br>$', {}, [rawtext('bar')])),
+             rawtext('</p>'),
+             ('endScope', ()),
              ])
 
     def check_replace_1(self):
         self._run_check("<p tal:replace='string:foo'>bar</p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:replace': 'string:foo'}),
-             ('insertText', '$string:foo$',
-              [('startTag', 'p', [('tal:replace', 'string:foo', 'tal')]),
-               ('rawtext', 'bar</p>')]),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:replace': 'string:foo'},)),
+             ('insertText', ('$string:foo$',
+              [('startTag', ('p', [('tal:replace', 'string:foo', 'tal')])),
+               rawtext('bar</p>')])),
+             ('endScope', ()),
              ])
 
     def check_replace_2(self):
         self._run_check("<p tal:replace='text string:foo'>bar</p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:replace': 'text string:foo'}),
-             ('insertText', '$string:foo$',
-              [('startTag', 'p', [('tal:replace', 'text string:foo', 'tal')]),
-               ('rawtext', 'bar</p>')]),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:replace': 'text string:foo'},)),
+             ('insertText', ('$string:foo$',
+              [('startTag', ('p',
+                             [('tal:replace', 'text string:foo', 'tal')])),
+               rawtext('bar</p>')])),
+             ('endScope', ()),
              ])
 
     def check_replace_3(self):
         self._run_check("<p tal:replace='structure string:<br>'>bar</p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:replace': 'structure string:<br>'}),
-             ('insertStructure', '$string:<br>$', {},
-              [('startTag', 'p',
-                [('tal:replace', 'structure string:<br>', 'tal')]),
-               ('rawtext', 'bar</p>')]),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:replace': 'structure string:<br>'},)),
+             ('insertStructure', ('$string:<br>$', {},
+              [('startTag', ('p',
+                [('tal:replace', 'structure string:<br>', 'tal')])),
+               rawtext('bar</p>')])),
+             ('endScope', ()),
              ])
 
     def check_repeat(self):
         self._run_check("<p tal:repeat='x python:(1,2,3)'>"
                         "<span tal:replace='x'>dummy</span></p>", [
-             ('setPosition', (1, 0)),
-             ('beginScope',),
-             ('rawAttrs', {'tal:repeat': 'x python:(1,2,3)'}),
-             ('loop', 'x', '$python:(1,2,3)$',
-              [('startTag', 'p', [('tal:repeat', 'x python:(1,2,3)', 'tal')]),
-               ('setPosition', (1, 33)),
-               ('beginScope',),
-               ('rawAttrs', {'tal:replace': 'x'}),
-               ('insertText', '$x$',
-                [('startTag', 'span', [('tal:replace', 'x', 'tal')]),
-                 ('rawtext', 'dummy</span>')]),
-               ('endScope',),
-               ('rawtext', '</p>')]),
-             ('endScope',),
+             ('setPosition', ((1, 0),)),
+             ('beginScope', ()),
+             ('rawAttrs', ({'tal:repeat': 'x python:(1,2,3)'},)),
+             ('loop', ('x', '$python:(1,2,3)$',
+              [('startTag', ('p',
+                             [('tal:repeat', 'x python:(1,2,3)', 'tal')])),
+               ('setPosition', ((1, 33),)),
+               ('beginScope', ()),
+               ('rawAttrs', ({'tal:replace': 'x'},)),
+               ('insertText', ('$x$',
+                [('startTag', ('span', [('tal:replace', 'x', 'tal')])),
+                 rawtext('dummy</span>')])),
+               ('endScope', ()),
+               rawtext('</p>')])),
+             ('endScope', ()),
              ])
 
     def check_attributes_1(self):
         self._run_check("<a href='foo' name='bar' tal:attributes="
                         "'href string:http://www.zope.org; x string:y'>"
                         "link</a>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
             ('rawAttrs',
-             {'tal:attributes': 'href string:http://www.zope.org; x string:y',
-              'name': 'bar', 'href': 'foo'}),
-            ('startTag', 'a',
+             ({'tal:attributes': 'href string:http://www.zope.org; x string:y',
+               'name': 'bar', 'href': 'foo'},)),
+            ('startTag', ('a',
              [('href', 'foo', 'replace', '$string:http://www.zope.org$'),
               ('name', 'bar'),
               ('tal:attributes',
                'href string:http://www.zope.org; x string:y', 'tal'),
-              ('x', None, 'insert', '$string:y$')]),
-            ('rawtext', 'link</a>'),
-            ('endScope',),
+              ('x', None, 'insert', '$string:y$')])),
+            rawtext('link</a>'),
+            ('endScope', ()),
             ])
 
     def check_attributes_2(self):
         self._run_check("<p tal:replace='structure string:<img>' "
                         "tal:attributes='src string:foo.png'>duh</p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
             ('rawAttrs',
-             {'tal:attributes': 'src string:foo.png',
-              'tal:replace': 'structure string:<img>'}),
-            ('insertStructure', '$string:<img>$',
+             ({'tal:attributes': 'src string:foo.png',
+               'tal:replace': 'structure string:<img>'},)),
+            ('insertStructure', ('$string:<img>$',
              {'src': '$string:foo.png$'},
-             [('startTag', 'p',
+             [('startTag', ('p',
                [('tal:replace', 'structure string:<img>', 'tal'),
-                ('tal:attributes', 'src string:foo.png', 'tal')]),
-              ('rawtext', 'duh</p>')]),
-            ('endScope',),
+                ('tal:attributes', 'src string:foo.png', 'tal')])),
+              rawtext('duh</p>')])),
+            ('endScope', ()),
             ])
 
     def check_on_error_1(self):
         self._run_check("<p tal:on-error='string:error' "
                         "tal:content='notHere'>okay</p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
             ('rawAttrs',
-             {'tal:content': 'notHere', 'tal:on-error': 'string:error'}),
+             ({'tal:content': 'notHere', 'tal:on-error': 'string:error'},)),
             ('onError',
-             [('startTag', 'p',
-               [('tal:on-error', 'string:error', 'tal'),
-                ('tal:content', 'notHere', 'tal')]),
-              ('insertText', '$notHere$', [('rawtext', 'okay')]),
-              ('rawtext', '</p>')],
-             [('startTag', 'p',
-               [('tal:on-error', 'string:error', 'tal'),
-                ('tal:content', 'notHere', 'tal')]),
-              ('insertText', '$string:error$', []),
-              ('rawtext', '</p>')]),
-            ('endScope',),
+             ([('startTag', ('p',
+                [('tal:on-error', 'string:error', 'tal'),
+                 ('tal:content', 'notHere', 'tal')])),
+               ('insertText', ('$notHere$', [rawtext('okay')])),
+               rawtext('</p>')],
+              [('startTag', ('p',
+                [('tal:on-error', 'string:error', 'tal'),
+                 ('tal:content', 'notHere', 'tal')])),
+               ('insertText', ('$string:error$', [])),
+               rawtext('</p>')])),
+            ('endScope', ()),
             ])
 
     def check_on_error_2(self):
         self._run_check("<p tal:on-error='string:error' "
                         "tal:replace='notHere'>okay</p>", [
-            ('setPosition', (1, 0)),
-            ('beginScope',),
+            ('setPosition', ((1, 0),)),
+            ('beginScope', ()),
             ('rawAttrs',
-             {'tal:replace': 'notHere', 'tal:on-error': 'string:error'}),
+             ({'tal:replace': 'notHere', 'tal:on-error': 'string:error'},)),
             ('onError',
-             [('insertText', '$notHere$',
-               [('startTag', 'p',
-                 [('tal:on-error', 'string:error', 'tal'),
-                  ('tal:replace', 'notHere', 'tal')]),
-                ('rawtext', 'okay</p>')])],
-             [('startTag', 'p',
-               [('tal:on-error', 'string:error', 'tal'),
-                ('tal:replace', 'notHere', 'tal')]),
-              ('insertText', '$string:error$', []),
-              ('rawtext', '</p>')]),
-            ('endScope',),
+             ([('insertText', ('$notHere$',
+                [('startTag', ('p',
+                  [('tal:on-error', 'string:error', 'tal'),
+                   ('tal:replace', 'notHere', 'tal')])),
+                 rawtext('okay</p>')]))],
+              [('startTag', ('p',
+                [('tal:on-error', 'string:error', 'tal'),
+                 ('tal:replace', 'notHere', 'tal')])),
+               ('insertText', ('$string:error$', [])),
+               rawtext('</p>')])),
+            ('endScope', ()),
             ])
 
     def check_dup_attr(self):