genshi/genshi-test: genshi/tests/output.py annotate

annotate genshi/tests/output.py @ 347:c0a4114786cc experimental-inline

cspeedups branch: Merged [423:426/trunk].

author	cmlenz
date	Fri, 10 Nov 2006 17:38:50 +0000
parents	b592333efe1b
children	cc7f5b3fbbed 0742f421caba

rev	line source
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
821114ec4f69 Initial import. cmlenz parents: diff changeset	2 #
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 27 diff changeset	3 # Copyright (C) 2006 Edgewall Software
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	4 # All rights reserved.
821114ec4f69 Initial import. cmlenz parents: diff changeset	5 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
821114ec4f69 Initial import. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
230 24757b771651 Renamed Markup to Genshi in repository. cmlenz parents: 212 diff changeset	8 # are also available at http://genshi.edgewall.org/wiki/License.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	9 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	10 # This software consists of voluntary contributions made by many
821114ec4f69 Initial import. cmlenz parents: diff changeset	11 # individuals. For the exact contribution history, see the revision
230 24757b771651 Renamed Markup to Genshi in repository. cmlenz parents: 212 diff changeset	12 # history and logs, available at http://genshi.edgewall.org/log/.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	13
821114ec4f69 Initial import. cmlenz parents: diff changeset	14 import doctest
821114ec4f69 Initial import. cmlenz parents: diff changeset	15 import unittest
821114ec4f69 Initial import. cmlenz parents: diff changeset	16 import sys
821114ec4f69 Initial import. cmlenz parents: diff changeset	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 24757b771651 Renamed Markup to Genshi in repository. cmlenz parents: 212 diff changeset	19 from genshi.input import HTML, XML
24757b771651 Renamed Markup to Genshi in repository. cmlenz parents: 212 diff changeset	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 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	22
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	23
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	24 class XMLSerializerTestCase(unittest.TestCase):
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	25
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	26 def test_doctype_in_stream(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	27 stream = Stream([(Stream.DOCTYPE, DocType.HTML_STRICT, (None, -1, -1))])
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	28 output = stream.render(XMLSerializer)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	29 self.assertEqual('<!DOCTYPE html PUBLIC '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	30 '"-//W3C//DTD HTML 4.01//EN" '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	31 '"http://www.w3.org/TR/html4/strict.dtd">\n',
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	32 output)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	33
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	34 def test_doctype_in_stream_no_sysid(self):
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	35 stream = Stream([(Stream.DOCTYPE,
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	36 ('html', '-//W3C//DTD HTML 4.01//EN', None),
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	37 (None, -1, -1))])
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	38 output = stream.render(XMLSerializer)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	39 self.assertEqual('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">\n',
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	40 output)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	41
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	42 def test_doctype_in_stream_no_pubid(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	43 stream = Stream([
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	44 (Stream.DOCTYPE,
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	45 ('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	46 (None, -1, -1))
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	47 ])
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	48 output = stream.render(XMLSerializer)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	49 self.assertEqual('<!DOCTYPE html SYSTEM '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	50 '"http://www.w3.org/TR/html4/strict.dtd">\n',
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	51 output)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	52
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	53 def test_doctype_in_stream_no_pubid_or_sysid(self):
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	54 stream = Stream([(Stream.DOCTYPE, ('html', None, None),
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	55 (None, -1, -1))])
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	56 output = stream.render(XMLSerializer)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	57 self.assertEqual('<!DOCTYPE html>\n', output)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	58
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	59 def test_serializer_doctype(self):
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	60 stream = Stream([])
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	61 output = stream.render(XMLSerializer, doctype=DocType.HTML_STRICT)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	62 self.assertEqual('<!DOCTYPE html PUBLIC '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	63 '"-//W3C//DTD HTML 4.01//EN" '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	64 '"http://www.w3.org/TR/html4/strict.dtd">\n',
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	65 output)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	66
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	67 def test_doctype_one_and_only(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	68 stream = Stream([
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	69 (Stream.DOCTYPE, ('html', None, None), (None, -1, -1))
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	70 ])
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	71 output = stream.render(XMLSerializer, doctype=DocType.HTML_STRICT)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	72 self.assertEqual('<!DOCTYPE html PUBLIC '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	73 '"-//W3C//DTD HTML 4.01//EN" '
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	74 '"http://www.w3.org/TR/html4/strict.dtd">\n',
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	75 output)
db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	76
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	77 def test_comment(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	78 stream = Stream([(Stream.COMMENT, 'foo bar', (None, -1, -1))])
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	79 output = stream.render(XMLSerializer)
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	80 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	81
105 334a338847af Include processing instructions in serialized streams. cmlenz parents: 89 diff changeset	82 def test_processing_instruction(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	83 stream = Stream([(Stream.PI, ('python', 'x = 2'), (None, -1, -1))])
105 334a338847af Include processing instructions in serialized streams. cmlenz parents: 89 diff changeset	84 output = stream.render(XMLSerializer)
334a338847af Include processing instructions in serialized streams. cmlenz parents: 89 diff changeset	85 self.assertEqual('<?python x = 2?>', output)
334a338847af Include processing instructions in serialized streams. cmlenz parents: 89 diff changeset	86
313 caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	87 def test_nested_default_namespaces(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	88 stream = Stream([
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	89 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	90 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	91 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	92 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	93 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	94 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	95 (Stream.END_NS, '', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	96 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	97 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	98 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	99 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	100 (Stream.END_NS, '', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	101 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	102 (Stream.END, QName('div'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	103 (Stream.END_NS, '', (None, -1, -1))
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	104 ])
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	105 output = stream.render(XMLSerializer)
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	106 self.assertEqual("""<div xmlns="http://example.org/">
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	107 <p/>
313 caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	108 <p/>
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	109 </div>""", output)
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	110
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	111 def test_nested_bound_namespaces(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	112 stream = Stream([
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	113 (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	114 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	115 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	116 (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	117 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	118 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	119 (Stream.END_NS, 'x', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	120 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	121 (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	122 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	123 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	124 (Stream.END_NS, 'x', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	125 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	126 (Stream.END, QName('div'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	127 (Stream.END_NS, 'x', (None, -1, -1))
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	128 ])
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	129 output = stream.render(XMLSerializer)
313 caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	130 self.assertEqual("""<div xmlns:x="http://example.org/">
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	131 <p/>
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	132 <p/>
313 caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	133 </div>""", output)
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	134
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	135
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	136 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	137
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	138 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	139 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	140 stream = XML('<textarea name="foo">%s</textarea>' % content)
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	141 output = stream.render(XHTMLSerializer)
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	142 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	143
347 c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	144 def test_pre_whitespace(self):
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	145 content = '\nHey <em>there</em>. \n\n I am indented.\n'
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	146 stream = XML('<pre>%s</pre>' % content)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	147 output = stream.render(XHTMLSerializer)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	148 self.assertEqual('<pre>%s</pre>' % content, output)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	149
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	150 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	151 text = '<foo xml:space="preserve"> Do not mess \n\n with me </foo>'
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	152 output = XML(text).render(XHTMLSerializer)
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	153 self.assertEqual(text, output)
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	154
177 dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	155 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	156 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	157 <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	158 </html>"""
177 dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	159 output = XML(text).render(XHTMLSerializer)
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	160 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	161 <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	162 </html>""", output)
177 dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	163
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	164 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	165 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	166 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	167 /]]>/</script>"""
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	168 output = XML(text).render(XHTMLSerializer)
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	169 self.assertEqual(text, output)
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	170
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	171 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	172 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	173 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	174 /]]>/</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	175 output = XML(text).render(XHTMLSerializer)
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	176 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	177
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	178 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	179 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	180 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	181 /]]>/</style>"""
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	182 output = XML(text).render(XHTMLSerializer)
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	183 self.assertEqual(text, output)
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	184
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	185 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	186 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	187 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	188 /]]>/</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	189 output = XML(text).render(XHTMLSerializer)
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	190 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	191
158 8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	192 def test_embedded_svg(self):
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	193 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	194 <body>
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	195 <button>
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	196 <svg:svg width="600px" height="400px">
160 faea6db52ef1 Attribute order in parsed XML is now preserved. cmlenz parents: 158 diff changeset	197 <svg:polygon id="triangle" points="50,50 50,300 300,300" />
158 8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	198 </svg:svg>
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	199 </button>
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	200 </body>
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	201 </html>"""
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	202 output = XML(text).render(XHTMLSerializer)
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	203 self.assertEqual(text, output)
8e81177059f3 * Add test case for SVG content embedded in an HTML document. cmlenz parents: 143 diff changeset	204
177 dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	205 def test_xhtml_namespace_prefix(self):
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	206 text = """<html:div xmlns:html="http://www.w3.org/1999/xhtml">
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	207 <html:strong>Hello</html:strong>
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	208 </html:div>"""
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	209 output = XML(text).render(XHTMLSerializer)
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	210 self.assertEqual(text, output)
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	211
313 caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	212 def test_nested_default_namespaces(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	213 stream = Stream([
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	214 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	215 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	216 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	217 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	218 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	219 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	220 (Stream.END_NS, '', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	221 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	222 (Stream.START_NS, ('', 'http://example.org/'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	223 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	224 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	225 (Stream.END_NS, '', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	226 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	227 (Stream.END, QName('div'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	228 (Stream.END_NS, '', (None, -1, -1))
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	229 ])
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	230 output = stream.render(XHTMLSerializer)
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	231 self.assertEqual("""<div xmlns="http://example.org/">
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	232 <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	233 <p></p>
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	234 </div>""", output)
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	235
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	236 def test_nested_bound_namespaces(self):
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	237 stream = Stream([
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	238 (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	239 (Stream.START, (QName('div'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	240 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	241 (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	242 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	243 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	244 (Stream.END_NS, 'x', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	245 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	246 (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	247 (Stream.START, (QName('p'), Attrs()), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	248 (Stream.END, QName('p'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	249 (Stream.END_NS, 'x', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	250 (Stream.TEXT, '\n ', (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	251 (Stream.END, QName('div'), (None, -1, -1)),
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	252 (Stream.END_NS, 'x', (None, -1, -1))
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	253 ])
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	254 output = stream.render(XHTMLSerializer)
313 caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	255 self.assertEqual("""<div xmlns:x="http://example.org/">
314 b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	256 <p></p>
b592333efe1b Improved the unit tests for nested namespaces in serialization. cmlenz parents: 313 diff changeset	257 <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	258 </div>""", output)
caafc67d2d0f Handle expressions containing non-ASCII strings as arguments for `py:with`, `py:def`, and `py:for`. cmlenz parents: 280 diff changeset	259
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	260
93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	261 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	262
347 c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	263 def test_textarea_whitespace(self):
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	264 content = '\nHey there. \n\n I am indented.\n'
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	265 stream = XML('<textarea name="foo">%s</textarea>' % content)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	266 output = stream.render(HTMLSerializer)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	267 self.assertEqual('<textarea name="foo">%s</textarea>' % content, output)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	268
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	269 def test_pre_whitespace(self):
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	270 content = '\nHey <em>there</em>. \n\n I am indented.\n'
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	271 stream = XML('<pre>%s</pre>' % content)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	272 output = stream.render(HTMLSerializer)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	273 self.assertEqual('<pre>%s</pre>' % content, output)
c0a4114786cc cspeedups branch: Merged [423:426/trunk]. cmlenz parents: 314 diff changeset	274
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	275 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	276 text = '<foo xml:space="preserve"> Do not mess \n\n with me </foo>'
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	277 output = XML(text).render(HTMLSerializer)
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	278 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	279
177 dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	280 def test_empty_script(self):
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	281 text = '<script src="foo.js" />'
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	282 output = XML(text).render(XHTMLSerializer)
dbae9efe5704 * Minor fix for the XHTML serializer (the local namespace var got clobbered) cmlenz parents: 160 diff changeset	283 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	284
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	285 def test_script_escaping(self):
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	286 text = '<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	287 output = XML(text).render(HTMLSerializer)
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	288 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	289 output)
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	290
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	291 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	292 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	293 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	294 </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	295 output = XML(text).render(HTMLSerializer)
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	296 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	297 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	298 </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	299
141 b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	300 def test_style_escaping(self):
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	301 text = '<style>html > body { display: none; }</style>'
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	302 output = XML(text).render(HTMLSerializer)
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	303 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	304 output)
b3ceaa35fb6b * No escaping of `<script>` or `<style>` tags in HTML output (see #24) cmlenz parents: 123 diff changeset	305
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	306 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	307 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	308 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	309 </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	310 output = XML(text).render(HTMLSerializer)
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	311 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	312 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	313 </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	314
123 93bbdcf9428b Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved. cmlenz parents: 105 diff changeset	315
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	316 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	317
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	318 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	319 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	320 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	321
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	322 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	323 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	324 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	325 [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	326
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	327 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	328 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	329 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	330 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	331 [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	332
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	333
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	334 def suite():
821114ec4f69 Initial import. cmlenz parents: diff changeset	335 suite = unittest.TestSuite()
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	336 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	337 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	338 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	339 suite.addTest(unittest.makeSuite(EmptyTagFilterTestCase, 'test'))
85 db8f2958c670 Improve handling of DOCTYPE declarations. cmlenz parents: 66 diff changeset	340 suite.addTest(doctest.DocTestSuite(XMLSerializer.__module__))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	341 return suite
821114ec4f69 Initial import. cmlenz parents: diff changeset	342
821114ec4f69 Initial import. cmlenz parents: diff changeset	343 if __name__ == '__main__':
821114ec4f69 Initial import. cmlenz parents: diff changeset	344 unittest.main(defaultTest='suite')

Mercurial > genshi > genshi-test

annotate genshi/tests/output.py @ 347:c0a4114786cc experimental-inline