Mercurial > genshi > genshi-test
annotate genshi/tests/output.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 |
rev | line source |
---|---|
1 | 1 # -*- coding: utf-8 -*- |
2 # | |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
3 # Copyright (C) 2006-2008 Edgewall Software |
1 | 4 # All rights reserved. |
5 # | |
6 # This software is licensed as described in the file COPYING, which | |
7 # you should have received as part of this distribution. The terms | |
230 | 8 # are also available at http://genshi.edgewall.org/wiki/License. |
1 | 9 # |
10 # This software consists of voluntary contributions made by many | |
11 # individuals. For the exact contribution history, see the revision | |
230 | 12 # history and logs, available at http://genshi.edgewall.org/log/. |
1 | 13 |
14 import doctest | |
15 import unittest | |
16 import sys | |
17 | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
18 from genshi.core import Attrs, Stream, QName |
230 | 19 from genshi.input import HTML, XML |
20 from genshi.output import DocType, XMLSerializer, XHTMLSerializer, \ | |
212
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
21 HTMLSerializer, EmptyTagFilter |
85 | 22 |
23 | |
24 class XMLSerializerTestCase(unittest.TestCase): | |
25 | |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
26 def test_with_xml_decl(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
27 stream = Stream([(Stream.XML_DECL, ('1.0', None, -1), (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
28 output = stream.render(XMLSerializer, doctype='xhtml', encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
29 self.assertEqual('<?xml version="1.0"?>\n' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
30 '<!DOCTYPE html PUBLIC ' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
31 '"-//W3C//DTD XHTML 1.0 Strict//EN" ' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
32 '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n', |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
33 output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
34 |
85 | 35 def test_doctype_in_stream(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
36 stream = Stream([(Stream.DOCTYPE, DocType.HTML_STRICT, (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
37 output = stream.render(XMLSerializer, encoding=None) |
85 | 38 self.assertEqual('<!DOCTYPE html PUBLIC ' |
39 '"-//W3C//DTD HTML 4.01//EN" ' | |
40 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
41 output) | |
42 | |
43 def test_doctype_in_stream_no_sysid(self): | |
44 stream = Stream([(Stream.DOCTYPE, | |
45 ('html', '-//W3C//DTD HTML 4.01//EN', None), | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
46 (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
47 output = stream.render(XMLSerializer, encoding=None) |
85 | 48 self.assertEqual('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">\n', |
49 output) | |
50 | |
51 def test_doctype_in_stream_no_pubid(self): | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
52 stream = Stream([ |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
53 (Stream.DOCTYPE, |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
54 ('html', None, 'http://www.w3.org/TR/html4/strict.dtd'), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
55 (None, -1, -1)) |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
56 ]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
57 output = stream.render(XMLSerializer, encoding=None) |
85 | 58 self.assertEqual('<!DOCTYPE html SYSTEM ' |
59 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
60 output) | |
61 | |
62 def test_doctype_in_stream_no_pubid_or_sysid(self): | |
63 stream = Stream([(Stream.DOCTYPE, ('html', None, None), | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
64 (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
65 output = stream.render(XMLSerializer, encoding=None) |
85 | 66 self.assertEqual('<!DOCTYPE html>\n', output) |
67 | |
68 def test_serializer_doctype(self): | |
69 stream = Stream([]) | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
70 output = stream.render(XMLSerializer, doctype=DocType.HTML_STRICT, |
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
71 encoding=None) |
85 | 72 self.assertEqual('<!DOCTYPE html PUBLIC ' |
73 '"-//W3C//DTD HTML 4.01//EN" ' | |
74 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
75 output) | |
76 | |
77 def test_doctype_one_and_only(self): | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
78 stream = Stream([ |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
79 (Stream.DOCTYPE, ('html', None, None), (None, -1, -1)) |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
80 ]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
81 output = stream.render(XMLSerializer, doctype=DocType.HTML_STRICT, |
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
82 encoding=None) |
85 | 83 self.assertEqual('<!DOCTYPE html PUBLIC ' |
84 '"-//W3C//DTD HTML 4.01//EN" ' | |
85 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
86 output) | |
87 | |
89
d4c7617900e3
Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents:
85
diff
changeset
|
88 def test_comment(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
89 stream = Stream([(Stream.COMMENT, 'foo bar', (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
90 output = stream.render(XMLSerializer, encoding=None) |
89
d4c7617900e3
Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents:
85
diff
changeset
|
91 self.assertEqual('<!--foo bar-->', output) |
d4c7617900e3
Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output.
cmlenz
parents:
85
diff
changeset
|
92 |
105
334a338847af
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
93 def test_processing_instruction(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
94 stream = Stream([(Stream.PI, ('python', 'x = 2'), (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
95 output = stream.render(XMLSerializer, encoding=None) |
105
334a338847af
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
96 self.assertEqual('<?python x = 2?>', output) |
334a338847af
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
97 |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
98 def test_nested_default_namespaces(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
99 stream = Stream([ |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
100 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), |
500 | 101 (Stream.START, (QName('http://example.org/}div'), Attrs()), (None, -1, -1)), |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
102 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
103 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), |
500 | 104 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), |
105 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
106 (Stream.END_NS, '', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
107 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
108 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), |
500 | 109 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), |
110 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
111 (Stream.END_NS, '', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
112 (Stream.TEXT, '\n ', (None, -1, -1)), |
500 | 113 (Stream.END, QName('http://example.org/}div'), (None, -1, -1)), |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
114 (Stream.END_NS, '', (None, -1, -1)) |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
115 ]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
116 output = stream.render(XMLSerializer, encoding=None) |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
117 self.assertEqual("""<div xmlns="http://example.org/"> |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
118 <p/> |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
119 <p/> |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
120 </div>""", output) |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
121 |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
122 def test_nested_bound_namespaces(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
123 stream = Stream([ |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
124 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), |
500 | 125 (Stream.START, (QName('http://example.org/}div'), Attrs()), (None, -1, -1)), |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
126 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
127 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), |
500 | 128 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), |
129 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
130 (Stream.END_NS, 'x', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
131 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
132 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), |
500 | 133 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), |
134 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
135 (Stream.END_NS, 'x', (None, -1, -1)), | |
136 (Stream.TEXT, '\n ', (None, -1, -1)), | |
137 (Stream.END, QName('http://example.org/}div'), (None, -1, -1)), | |
138 (Stream.END_NS, 'x', (None, -1, -1)) | |
139 ]) | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
140 output = stream.render(XMLSerializer, encoding=None) |
500 | 141 self.assertEqual("""<x:div xmlns:x="http://example.org/"> |
142 <x:p/> | |
143 <x:p/> | |
144 </x:div>""", output) | |
145 | |
146 def test_multiple_default_namespaces(self): | |
147 stream = Stream([ | |
148 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)), | |
149 (Stream.TEXT, '\n ', (None, -1, -1)), | |
150 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), | |
151 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), | |
152 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
153 (Stream.END_NS, '', (None, -1, -1)), | |
154 (Stream.TEXT, '\n ', (None, -1, -1)), | |
155 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), | |
156 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), | |
157 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
158 (Stream.END_NS, '', (None, -1, -1)), | |
159 (Stream.TEXT, '\n ', (None, -1, -1)), | |
160 (Stream.END, QName('div'), (None, -1, -1)), | |
161 ]) | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
162 output = stream.render(XMLSerializer, encoding=None) |
500 | 163 self.assertEqual("""<div> |
164 <p xmlns="http://example.org/"/> | |
165 <p xmlns="http://example.org/"/> | |
166 </div>""", output) | |
167 | |
168 def test_multiple_bound_namespaces(self): | |
169 stream = Stream([ | |
170 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)), | |
171 (Stream.TEXT, '\n ', (None, -1, -1)), | |
172 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), | |
173 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), | |
174 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
175 (Stream.END_NS, 'x', (None, -1, -1)), | |
176 (Stream.TEXT, '\n ', (None, -1, -1)), | |
177 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), | |
178 (Stream.START, (QName('http://example.org/}p'), Attrs()), (None, -1, -1)), | |
179 (Stream.END, QName('http://example.org/}p'), (None, -1, -1)), | |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
180 (Stream.END_NS, 'x', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
181 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
182 (Stream.END, QName('div'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
183 ]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
184 output = stream.render(XMLSerializer, encoding=None) |
500 | 185 self.assertEqual("""<div> |
186 <x:p xmlns:x="http://example.org/"/> | |
187 <x:p xmlns:x="http://example.org/"/> | |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
188 </div>""", output) |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
189 |
500 | 190 def test_atom_with_xhtml(self): |
191 text = """<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en"> | |
192 <id>urn:uuid:c60843aa-0da8-4fa6-bbe5-98007bc6774e</id> | |
193 <updated>2007-01-28T11:36:02.807108-06:00</updated> | |
194 <title type="xhtml"> | |
195 <div xmlns="http://www.w3.org/1999/xhtml">Example</div> | |
196 </title> | |
197 <subtitle type="xhtml"> | |
198 <div xmlns="http://www.w3.org/1999/xhtml">Bla bla bla</div> | |
199 </subtitle> | |
200 <icon/> | |
201 </feed>""" | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
202 output = XML(text).render(XMLSerializer, encoding=None) |
500 | 203 self.assertEqual(text, output) |
204 | |
1 | 205 |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
206 class XHTMLSerializerTestCase(unittest.TestCase): |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
207 |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
208 def test_xml_decl_dropped(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
209 stream = Stream([(Stream.XML_DECL, ('1.0', None, -1), (None, -1, -1))]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
210 output = stream.render(XHTMLSerializer, doctype='xhtml', encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
211 self.assertEqual('<!DOCTYPE html PUBLIC ' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
212 '"-//W3C//DTD XHTML 1.0 Strict//EN" ' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
213 '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n', |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
214 output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
215 |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
216 def test_xml_decl_included(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
217 stream = Stream([(Stream.XML_DECL, ('1.0', None, -1), (None, -1, -1))]) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
218 output = stream.render(XHTMLSerializer, doctype='xhtml', |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
219 drop_xml_decl=False, encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
220 self.assertEqual('<?xml version="1.0"?>\n' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
221 '<!DOCTYPE html PUBLIC ' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
222 '"-//W3C//DTD XHTML 1.0 Strict//EN" ' |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
223 '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n', |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
224 output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
225 |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
226 def test_xml_lang(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
227 text = '<p xml:lang="en">English text</p>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
228 output = XML(text).render(XHTMLSerializer, encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
229 self.assertEqual('<p lang="en" xml:lang="en">English text</p>', output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
230 |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
231 def test_xml_lang_nodup(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
232 text = '<p xml:lang="en" lang="en">English text</p>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
233 output = XML(text).render(XHTMLSerializer, encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
234 self.assertEqual('<p xml:lang="en" lang="en">English text</p>', output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
235 |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
236 def test_textarea_whitespace(self): |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
237 content = '\nHey there. \n\n I am indented.\n' |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
238 stream = XML('<textarea name="foo">%s</textarea>' % content) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
239 output = stream.render(XHTMLSerializer, encoding=None) |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
240 self.assertEqual('<textarea name="foo">%s</textarea>' % content, output) |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
241 |
347 | 242 def test_pre_whitespace(self): |
243 content = '\nHey <em>there</em>. \n\n I am indented.\n' | |
244 stream = XML('<pre>%s</pre>' % content) | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
245 output = stream.render(XHTMLSerializer, encoding=None) |
347 | 246 self.assertEqual('<pre>%s</pre>' % content, output) |
247 | |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
248 def test_xml_space(self): |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
249 text = '<foo xml:space="preserve"> Do not mess \n\n with me </foo>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
250 output = XML(text).render(XHTMLSerializer, encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
251 self.assertEqual('<foo> Do not mess \n\n with me </foo>', output) |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
252 |
177
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
253 def test_empty_script(self): |
178
8fb7df2e1281
Fix bug in XHTML serialization: all elements were allowed to be written out as empty if the namespace was set.
cmlenz
parents:
177
diff
changeset
|
254 text = """<html xmlns="http://www.w3.org/1999/xhtml"> |
8fb7df2e1281
Fix bug in XHTML serialization: all elements were allowed to be written out as empty if the namespace was set.
cmlenz
parents:
177
diff
changeset
|
255 <script src="foo.js" /> |
8fb7df2e1281
Fix bug in XHTML serialization: all elements were allowed to be written out as empty if the namespace was set.
cmlenz
parents:
177
diff
changeset
|
256 </html>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
257 output = XML(text).render(XHTMLSerializer, encoding=None) |
178
8fb7df2e1281
Fix bug in XHTML serialization: all elements were allowed to be written out as empty if the namespace was set.
cmlenz
parents:
177
diff
changeset
|
258 self.assertEqual("""<html xmlns="http://www.w3.org/1999/xhtml"> |
8fb7df2e1281
Fix bug in XHTML serialization: all elements were allowed to be written out as empty if the namespace was set.
cmlenz
parents:
177
diff
changeset
|
259 <script src="foo.js"></script> |
8fb7df2e1281
Fix bug in XHTML serialization: all elements were allowed to be written out as empty if the namespace was set.
cmlenz
parents:
177
diff
changeset
|
260 </html>""", output) |
177
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
261 |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
262 def test_script_escaping(self): |
143
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
263 text = """<script>/*<![CDATA[*/ |
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
264 if (1 < 2) { alert("Doh"); } |
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
265 /*]]>*/</script>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
266 output = XML(text).render(XHTMLSerializer, encoding=None) |
143
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
267 self.assertEqual(text, output) |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
268 |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
269 def test_script_escaping_with_namespace(self): |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
270 text = """<script xmlns="http://www.w3.org/1999/xhtml">/*<![CDATA[*/ |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
271 if (1 < 2) { alert("Doh"); } |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
272 /*]]>*/</script>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
273 output = XML(text).render(XHTMLSerializer, encoding=None) |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
274 self.assertEqual(text, output) |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
275 |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
276 def test_style_escaping(self): |
143
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
277 text = """<style>/*<![CDATA[*/ |
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
278 html > body { display: none; } |
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
279 /*]]>*/</style>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
280 output = XML(text).render(XHTMLSerializer, encoding=None) |
143
ef761afcedff
CDATA sections in XML input now appear as CDATA sections in the output. This should address the problem with escaping the contents of `<style>` and `<script>` elements, which would only get interpreted correctly if the output was served as `application/xhtml+xml`. Closes #24.
cmlenz
parents:
141
diff
changeset
|
281 self.assertEqual(text, output) |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
282 |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
283 def test_style_escaping_with_namespace(self): |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
284 text = """<style xmlns="http://www.w3.org/1999/xhtml">/*<![CDATA[*/ |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
285 html > body { display: none; } |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
286 /*]]>*/</style>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
287 output = XML(text).render(XHTMLSerializer, encoding=None) |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
288 self.assertEqual(text, output) |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
289 |
158
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
290 def test_embedded_svg(self): |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
291 text = """<html xmlns="http://www.w3.org/1999/xhtml" xmlns:svg="http://www.w3.org/2000/svg"> |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
292 <body> |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
293 <button> |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
294 <svg:svg width="600px" height="400px"> |
500 | 295 <svg:polygon id="triangle" points="50,50 50,300 300,300"></svg:polygon> |
158
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
296 </svg:svg> |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
297 </button> |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
298 </body> |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
299 </html>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
300 output = XML(text).render(XHTMLSerializer, encoding=None) |
158
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
301 self.assertEqual(text, output) |
8e81177059f3
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
302 |
177
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
303 def test_xhtml_namespace_prefix(self): |
500 | 304 text = """<div xmlns="http://www.w3.org/1999/xhtml"> |
305 <strong>Hello</strong> | |
306 </div>""" | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
307 output = XML(text).render(XHTMLSerializer, encoding=None) |
177
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
308 self.assertEqual(text, output) |
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
309 |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
310 def test_nested_default_namespaces(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
311 stream = Stream([ |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
312 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
313 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
314 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
315 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
316 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
317 (Stream.END, QName('p'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
318 (Stream.END_NS, '', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
319 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
320 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
321 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
322 (Stream.END, QName('p'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
323 (Stream.END_NS, '', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
324 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
325 (Stream.END, QName('div'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
326 (Stream.END_NS, '', (None, -1, -1)) |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
327 ]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
328 output = stream.render(XHTMLSerializer, encoding=None) |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
329 self.assertEqual("""<div xmlns="http://example.org/"> |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
330 <p></p> |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
331 <p></p> |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
332 </div>""", output) |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
333 |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
334 def test_nested_bound_namespaces(self): |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
335 stream = Stream([ |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
336 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
337 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
338 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
339 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
340 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
341 (Stream.END, QName('p'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
342 (Stream.END_NS, 'x', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
343 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
344 (Stream.START_NS, ('x', 'http://example.org/'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
345 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
346 (Stream.END, QName('p'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
347 (Stream.END_NS, 'x', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
348 (Stream.TEXT, '\n ', (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
349 (Stream.END, QName('div'), (None, -1, -1)), |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
350 (Stream.END_NS, 'x', (None, -1, -1)) |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
351 ]) |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
352 output = stream.render(XHTMLSerializer, encoding=None) |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
353 self.assertEqual("""<div xmlns:x="http://example.org/"> |
314
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
354 <p></p> |
b592333efe1b
Improved the unit tests for nested namespaces in serialization.
cmlenz
parents:
313
diff
changeset
|
355 <p></p> |
313
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
356 </div>""", output) |
caafc67d2d0f
Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`.
cmlenz
parents:
280
diff
changeset
|
357 |
500 | 358 def test_html5_doctype(self): |
359 stream = HTML('<html></html>') | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
360 output = stream.render(XHTMLSerializer, doctype=DocType.HTML5, |
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
361 encoding=None) |
500 | 362 self.assertEqual('<!DOCTYPE html>\n<html></html>', output) |
363 | |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
364 |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
365 class HTMLSerializerTestCase(unittest.TestCase): |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
366 |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
367 def test_xml_lang(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
368 text = '<p xml:lang="en">English text</p>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
369 output = XML(text).render(HTMLSerializer, encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
370 self.assertEqual('<p lang="en">English text</p>', output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
371 |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
372 def test_xml_lang_nodup(self): |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
373 text = '<p lang="en" xml:lang="en">English text</p>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
374 output = XML(text).render(HTMLSerializer, encoding=None) |
820
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
375 self.assertEqual('<p lang="en">English text</p>', output) |
1837f39efd6f
Sync (old) experimental inline branch with trunk@1027.
cmlenz
parents:
500
diff
changeset
|
376 |
347 | 377 def test_textarea_whitespace(self): |
378 content = '\nHey there. \n\n I am indented.\n' | |
379 stream = XML('<textarea name="foo">%s</textarea>' % content) | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
380 output = stream.render(HTMLSerializer, encoding=None) |
347 | 381 self.assertEqual('<textarea name="foo">%s</textarea>' % content, output) |
382 | |
383 def test_pre_whitespace(self): | |
384 content = '\nHey <em>there</em>. \n\n I am indented.\n' | |
385 stream = XML('<pre>%s</pre>' % content) | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
386 output = stream.render(HTMLSerializer, encoding=None) |
347 | 387 self.assertEqual('<pre>%s</pre>' % content, output) |
388 | |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
389 def test_xml_space(self): |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
390 text = '<foo xml:space="preserve"> Do not mess \n\n with me </foo>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
391 output = XML(text).render(HTMLSerializer, encoding=None) |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
392 self.assertEqual('<foo> Do not mess \n\n with me </foo>', output) |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
393 |
177
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
394 def test_empty_script(self): |
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
395 text = '<script src="foo.js" />' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
396 output = XML(text).render(HTMLSerializer, encoding=None) |
177
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
397 self.assertEqual('<script src="foo.js"></script>', output) |
dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
398 |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
399 def test_script_escaping(self): |
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
400 text = '<script>if (1 < 2) { alert("Doh"); }</script>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
401 output = XML(text).render(HTMLSerializer, encoding=None) |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
402 self.assertEqual('<script>if (1 < 2) { alert("Doh"); }</script>', |
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
403 output) |
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
404 |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
405 def test_script_escaping_with_namespace(self): |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
406 text = """<script xmlns="http://www.w3.org/1999/xhtml"> |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
407 if (1 < 2) { alert("Doh"); } |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
408 </script>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
409 output = XML(text).render(HTMLSerializer, encoding=None) |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
410 self.assertEqual("""<script> |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
411 if (1 < 2) { alert("Doh"); } |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
412 </script>""", output) |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
413 |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
414 def test_style_escaping(self): |
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
415 text = '<style>html > body { display: none; }</style>' |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
416 output = XML(text).render(HTMLSerializer, encoding=None) |
141
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
417 self.assertEqual('<style>html > body { display: none; }</style>', |
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
418 output) |
b3ceaa35fb6b
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
419 |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
420 def test_style_escaping_with_namespace(self): |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
421 text = """<style xmlns="http://www.w3.org/1999/xhtml"> |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
422 html > body { display: none; } |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
423 </style>""" |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
424 output = XML(text).render(HTMLSerializer, encoding=None) |
280
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
425 self.assertEqual("""<style> |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
426 html > body { display: none; } |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
427 </style>""", output) |
e68705cb462e
The content of `<script>` and `<style>` elements is no longer escaped when serializing to HTML but declaring the XHTML namespace in the template.
cmlenz
parents:
230
diff
changeset
|
428 |
500 | 429 def test_html5_doctype(self): |
430 stream = HTML('<html></html>') | |
902
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
431 output = stream.render(HTMLSerializer, doctype=DocType.HTML5, |
09cc3627654c
Sync `experimental/inline` branch with [source:trunk@1126].
cmlenz
parents:
820
diff
changeset
|
432 encoding=None) |
500 | 433 self.assertEqual('<!DOCTYPE html>\n<html></html>', output) |
434 | |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
435 |
212
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
436 class EmptyTagFilterTestCase(unittest.TestCase): |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
437 |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
438 def test_empty(self): |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
439 stream = XML('<elem></elem>') | EmptyTagFilter() |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
440 self.assertEqual([EmptyTagFilter.EMPTY], [ev[0] for ev in stream]) |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
441 |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
442 def test_text_content(self): |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
443 stream = XML('<elem>foo</elem>') | EmptyTagFilter() |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
444 self.assertEqual([Stream.START, Stream.TEXT, Stream.END], |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
445 [ev[0] for ev in stream]) |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
446 |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
447 def test_elem_content(self): |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
448 stream = XML('<elem><sub /><sub /></elem>') | EmptyTagFilter() |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
449 self.assertEqual([Stream.START, EmptyTagFilter.EMPTY, |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
450 EmptyTagFilter.EMPTY, Stream.END], |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
451 [ev[0] for ev in stream]) |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
452 |
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
453 |
1 | 454 def suite(): |
455 suite = unittest.TestSuite() | |
85 | 456 suite.addTest(unittest.makeSuite(XMLSerializerTestCase, 'test')) |
123
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
457 suite.addTest(unittest.makeSuite(XHTMLSerializerTestCase, 'test')) |
93bbdcf9428b
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
458 suite.addTest(unittest.makeSuite(HTMLSerializerTestCase, 'test')) |
212
e8c43127d9a9
Refactored the handling of empty tags in the serializer: use an `EmptyTagFilter` that combines adjacent start/end events, instead of the generic pushback-iterator.
cmlenz
parents:
178
diff
changeset
|
459 suite.addTest(unittest.makeSuite(EmptyTagFilterTestCase, 'test')) |
85 | 460 suite.addTest(doctest.DocTestSuite(XMLSerializer.__module__)) |
1 | 461 return suite |
462 | |
463 if __name__ == '__main__': | |
464 unittest.main(defaultTest='suite') |