Mercurial > genshi > mirror
annotate markup/tests/output.py @ 209:fc6b2fb66518 trunk
* Fix bug in handling of undefined entities. Thanks to Arnar for reporting the issue on IRC.
* Enable the `XMLParser` to handle HTML entities without requiring the declaration of a HTML document type.
author | cmlenz |
---|---|
date | Tue, 29 Aug 2006 16:34:40 +0000 |
parents | ba7556e3a835 |
children | 0141f45c18e1 |
rev | line source |
---|---|
1 | 1 # -*- coding: utf-8 -*- |
2 # | |
66
59eb24184e9c
Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents:
27
diff
changeset
|
3 # Copyright (C) 2006 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 | |
66
59eb24184e9c
Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents:
27
diff
changeset
|
8 # are also available at http://markup.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 | |
66
59eb24184e9c
Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents:
27
diff
changeset
|
12 # history and logs, available at http://markup.edgewall.org/log/. |
1 | 13 |
14 import doctest | |
15 import unittest | |
16 import sys | |
17 | |
85 | 18 from markup.core import Stream |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
19 from markup.input import HTML, XML |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
20 from markup.output import DocType, XMLSerializer, XHTMLSerializer, \ |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
21 HTMLSerializer |
85 | 22 |
23 | |
24 class XMLSerializerTestCase(unittest.TestCase): | |
25 | |
26 def test_doctype_in_stream(self): | |
27 stream = Stream([(Stream.DOCTYPE, DocType.HTML_STRICT, ('?', -1, -1))]) | |
28 output = stream.render(XMLSerializer) | |
29 self.assertEqual('<!DOCTYPE html PUBLIC ' | |
30 '"-//W3C//DTD HTML 4.01//EN" ' | |
31 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
32 output) | |
33 | |
34 def test_doctype_in_stream_no_sysid(self): | |
35 stream = Stream([(Stream.DOCTYPE, | |
36 ('html', '-//W3C//DTD HTML 4.01//EN', None), | |
37 ('?', -1, -1))]) | |
38 output = stream.render(XMLSerializer) | |
39 self.assertEqual('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">\n', | |
40 output) | |
41 | |
42 def test_doctype_in_stream_no_pubid(self): | |
43 stream = Stream([(Stream.DOCTYPE, | |
44 ('html', None, 'http://www.w3.org/TR/html4/strict.dtd'), | |
45 ('?', -1, -1))]) | |
46 output = stream.render(XMLSerializer) | |
47 self.assertEqual('<!DOCTYPE html SYSTEM ' | |
48 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
49 output) | |
50 | |
51 def test_doctype_in_stream_no_pubid_or_sysid(self): | |
52 stream = Stream([(Stream.DOCTYPE, ('html', None, None), | |
53 ('?', -1, -1))]) | |
54 output = stream.render(XMLSerializer) | |
55 self.assertEqual('<!DOCTYPE html>\n', output) | |
56 | |
57 def test_serializer_doctype(self): | |
58 stream = Stream([]) | |
59 output = stream.render(XMLSerializer, doctype=DocType.HTML_STRICT) | |
60 self.assertEqual('<!DOCTYPE html PUBLIC ' | |
61 '"-//W3C//DTD HTML 4.01//EN" ' | |
62 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
63 output) | |
64 | |
65 def test_doctype_one_and_only(self): | |
66 stream = Stream([(Stream.DOCTYPE, ('html', None, None), ('?', -1, -1))]) | |
67 output = stream.render(XMLSerializer, doctype=DocType.HTML_STRICT) | |
68 self.assertEqual('<!DOCTYPE html PUBLIC ' | |
69 '"-//W3C//DTD HTML 4.01//EN" ' | |
70 '"http://www.w3.org/TR/html4/strict.dtd">\n', | |
71 output) | |
72 | |
89
80386d62814f
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
|
73 def test_comment(self): |
80386d62814f
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
|
74 stream = Stream([(Stream.COMMENT, 'foo bar', ('?', -1, -1))]) |
80386d62814f
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
|
75 output = stream.render(XMLSerializer) |
80386d62814f
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
|
76 self.assertEqual('<!--foo bar-->', output) |
80386d62814f
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 |
105
71f3db26eecb
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
78 def test_processing_instruction(self): |
71f3db26eecb
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
79 stream = Stream([(Stream.PI, ('python', 'x = 2'), ('?', -1, -1))]) |
71f3db26eecb
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
80 output = stream.render(XMLSerializer) |
71f3db26eecb
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
81 self.assertEqual('<?python x = 2?>', output) |
71f3db26eecb
Include processing instructions in serialized streams.
cmlenz
parents:
89
diff
changeset
|
82 |
1 | 83 |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
84 class XHTMLSerializerTestCase(unittest.TestCase): |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
85 |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
86 def test_textarea_whitespace(self): |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
87 content = '\nHey there. \n\n I am indented.\n' |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
88 stream = XML('<textarea name="foo">%s</textarea>' % content) |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
89 output = stream.render(XHTMLSerializer) |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
90 self.assertEqual('<textarea name="foo">%s</textarea>' % content, output) |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
91 |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
92 def test_xml_space(self): |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
93 text = '<foo xml:space="preserve"> Do not mess \n\n with me </foo>' |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
94 output = XML(text).render(XHTMLSerializer) |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
95 self.assertEqual(text, output) |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
96 |
177
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
97 def test_empty_script(self): |
178
ba7556e3a835
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
|
98 text = """<html xmlns="http://www.w3.org/1999/xhtml"> |
ba7556e3a835
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
|
99 <script src="foo.js" /> |
ba7556e3a835
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
|
100 </html>""" |
177
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
101 output = XML(text).render(XHTMLSerializer) |
178
ba7556e3a835
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
|
102 self.assertEqual("""<html xmlns="http://www.w3.org/1999/xhtml"> |
ba7556e3a835
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
|
103 <script src="foo.js"></script> |
ba7556e3a835
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
|
104 </html>""", output) |
177
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
105 |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
106 def test_script_escaping(self): |
143
3d4c214c979a
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
|
107 text = """<script>/*<![CDATA[*/ |
3d4c214c979a
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
|
108 if (1 < 2) { alert("Doh"); } |
3d4c214c979a
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
|
109 /*]]>*/</script>""" |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
110 output = XML(text).render(XHTMLSerializer) |
143
3d4c214c979a
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
|
111 self.assertEqual(text, output) |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
112 |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
113 def test_style_escaping(self): |
143
3d4c214c979a
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
|
114 text = """<style>/*<![CDATA[*/ |
3d4c214c979a
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
|
115 html > body { display: none; } |
3d4c214c979a
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
|
116 /*]]>*/</style>""" |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
117 output = XML(text).render(XHTMLSerializer) |
143
3d4c214c979a
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
|
118 self.assertEqual(text, output) |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
119 |
158
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
120 def test_embedded_svg(self): |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
121 text = """<html xmlns="http://www.w3.org/1999/xhtml" xmlns:svg="http://www.w3.org/2000/svg"> |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
122 <body> |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
123 <button> |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
124 <svg:svg width="600px" height="400px"> |
160 | 125 <svg:polygon id="triangle" points="50,50 50,300 300,300" /> |
158
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
126 </svg:svg> |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
127 </button> |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
128 </body> |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
129 </html>""" |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
130 output = XML(text).render(XHTMLSerializer) |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
131 self.assertEqual(text, output) |
3f23fafeef99
* Add test case for SVG content embedded in an HTML document.
cmlenz
parents:
143
diff
changeset
|
132 |
177
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
133 def test_xhtml_namespace_prefix(self): |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
134 text = """<html:div xmlns:html="http://www.w3.org/1999/xhtml"> |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
135 <html:strong>Hello</html:strong> |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
136 </html:div>""" |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
137 output = XML(text).render(XHTMLSerializer) |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
138 self.assertEqual(text, output) |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
139 |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
140 |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
141 class HTMLSerializerTestCase(unittest.TestCase): |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
142 |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
143 def test_xml_space(self): |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
144 text = '<foo xml:space="preserve"> Do not mess \n\n with me </foo>' |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
145 output = XML(text).render(HTMLSerializer) |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
146 self.assertEqual('<foo> Do not mess \n\n with me </foo>', output) |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
147 |
177
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
148 def test_empty_script(self): |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
149 text = '<script src="foo.js" />' |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
150 output = XML(text).render(XHTMLSerializer) |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
151 self.assertEqual('<script src="foo.js"></script>', output) |
553866249cb0
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
cmlenz
parents:
160
diff
changeset
|
152 |
141
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
153 def test_script_escaping(self): |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
154 text = '<script>if (1 < 2) { alert("Doh"); }</script>' |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
155 output = XML(text).render(HTMLSerializer) |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
156 self.assertEqual('<script>if (1 < 2) { alert("Doh"); }</script>', |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
157 output) |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
158 |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
159 def test_style_escaping(self): |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
160 text = '<style>html > body { display: none; }</style>' |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
161 output = XML(text).render(HTMLSerializer) |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
162 self.assertEqual('<style>html > body { display: none; }</style>', |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
163 output) |
520a5b7dd6d2
* No escaping of `<script>` or `<style>` tags in HTML output (see #24)
cmlenz
parents:
123
diff
changeset
|
164 |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
165 |
1 | 166 def suite(): |
167 suite = unittest.TestSuite() | |
85 | 168 suite.addTest(unittest.makeSuite(XMLSerializerTestCase, 'test')) |
123
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
169 suite.addTest(unittest.makeSuite(XHTMLSerializerTestCase, 'test')) |
10279d2eeec9
Fix for #18: whitespace in space-sensitive elements such as `<pre>` and `<textarea>` is now preserved.
cmlenz
parents:
105
diff
changeset
|
170 suite.addTest(unittest.makeSuite(HTMLSerializerTestCase, 'test')) |
85 | 171 suite.addTest(doctest.DocTestSuite(XMLSerializer.__module__)) |
1 | 172 return suite |
173 | |
174 if __name__ == '__main__': | |
175 unittest.main(defaultTest='suite') |